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

opentrons/hardware_control/ot3api.py

@@ -46,7 +46,6 @@ from opentrons.config.types import (
     LiquidProbeSettings,
 )
 from opentrons.drivers.rpi_drivers.types import USBPort, PortGroup
-from opentrons.hardware_control.nozzle_manager import NozzleConfigurationType
 from opentrons_shared_data.errors.exceptions import (
     EnumeratedError,
     PythonException,
@@ -99,6 +98,7 @@ from .types import (
     EstopState,
     HardwareFeatureFlags,
     FailedTipStateCheck,
+    PipetteSensorResponseQueue,
 )
 from .errors import (
     UpdateOngoingError,
@@ -144,8 +144,6 @@ from .backends.types import HWStopCondition
 from .backends.flex_protocol import FlexBackend
 from .backends.ot3simulator import OT3Simulator
 from .backends.errors import SubsystemUpdating
-from opentrons_hardware.firmware_bindings.constants import SensorId
-from opentrons_hardware.sensors.types import SensorDataType
 
 mod_log = logging.getLogger(__name__)
 
@@ -357,7 +355,9 @@ class OT3API(
     def _reset_last_mount(self) -> None:
         self._last_moved_mount = None
 
-    def _deck_from_machine(self, machine_pos: Dict[Axis, float]) -> Dict[Axis, float]:
+    def get_deck_from_machine(
+        self, machine_pos: Dict[Axis, float]
+    ) -> Dict[Axis, float]:
         return deck_from_machine(
             machine_pos=machine_pos,
             attitude=self._robot_calibration.deck_calibration.attitude,
@@ -800,6 +800,8 @@ class OT3API(
         """
         Function to update motor estimation for a set of axes
         """
+        await self._backend.update_motor_status()
+
         if axes is None:
             axes = [ax for ax in Axis]
 
@@ -968,8 +970,8 @@ class OT3API(
         ):
             # move toward home until a safe distance
             await self._backend.tip_action(
-                origin={Axis.Q: current_pos_float},
-                targets=[({Axis.Q: self._config.safe_home_distance}, 400)],
+                origin=current_pos_float,
+                targets=[(self._config.safe_home_distance, 400)],
             )
 
             # update current position
@@ -1046,14 +1048,14 @@ class OT3API(
 
     async def _cache_current_position(self) -> Dict[Axis, float]:
         """Cache current position from backend and return in absolute deck coords."""
-        self._current_position = self._deck_from_machine(
+        self._current_position = self.get_deck_from_machine(
             await self._backend.update_position()
         )
         return self._current_position
 
     async def _cache_encoder_position(self) -> Dict[Axis, float]:
         """Cache encoder position from backend and return in absolute deck coords."""
-        self._encoder_position = self._deck_from_machine(
+        self._encoder_position = self.get_deck_from_machine(
             await self._backend.update_encoder_position()
         )
         if self.has_gripper():
@@ -1253,7 +1255,9 @@ class OT3API(
                     message=f"{axis} is not present", detail={"axis": str(axis)}
                 )
 
+        self._log.info(f"Attempting to move {position} with speed {speed}.")
         if not self._backend.check_encoder_status(list(position.keys())):
+            self._log.info("Calling home in move_axes")
             await self.home()
         self._assert_motor_ok(list(position.keys()))
 
@@ -1464,6 +1468,10 @@ class OT3API(
         check_motion_bounds(to_check, target_position, bounds, check_bounds)
         self._log.info(f"Move: deck {target_position} becomes machine {machine_pos}")
         origin = await self._backend.update_position()
+
+        if self._gantry_load == GantryLoad.HIGH_THROUGHPUT:
+            origin[Axis.Q] = self._backend.gear_motor_position or 0.0
+
         async with contextlib.AsyncExitStack() as stack:
             if acquire_lock:
                 await stack.enter_async_context(self._motion_lock)
@@ -1665,7 +1673,12 @@ class OT3API(
         await self._backend.disengage_axes(which)
 
     async def engage_axes(self, which: List[Axis]) -> None:
-        await self._backend.engage_axes(which)
+        await self._backend.engage_axes(
+            [axis for axis in which if self._backend.axis_is_present(axis)]
+        )
+
+    def axis_is_present(self, axis: Axis) -> bool:
+        return self._backend.axis_is_present(axis)
 
     async def get_limit_switches(self) -> Dict[Axis, bool]:
         res = await self._backend.get_limit_switches()
@@ -1851,7 +1864,7 @@ class OT3API(
         if (
             self.gantry_load == GantryLoad.HIGH_THROUGHPUT
             and instrument.nozzle_manager.current_configuration.configuration
-            == NozzleConfigurationType.FULL
+            == top_types.NozzleConfigurationType.FULL
         ):
             spec = self._pipette_handler.plan_ht_pick_up_tip(
                 instrument.nozzle_manager.current_configuration.tip_count
@@ -2181,8 +2194,8 @@ class OT3API(
         # only move tip motors if they are not already below the sensor
         if tip_motor_pos_float < tip_presence_check_target:
             await self._backend.tip_action(
-                origin={Axis.Q: tip_motor_pos_float},
-                targets=[({Axis.Q: tip_presence_check_target}, 400)],
+                origin=tip_motor_pos_float,
+                targets=[(tip_presence_check_target, 400)],
             )
         try:
             yield
@@ -2253,11 +2266,11 @@ class OT3API(
             gear_origin_float = self._backend.gear_motor_position or 0.0
 
             move_targets = [
-                ({Axis.Q: move_segment.distance}, move_segment.speed or 400)
+                (move_segment.distance, move_segment.speed or 400)
                 for move_segment in pipette_spec
             ]
             await self._backend.tip_action(
-                origin={Axis.Q: gear_origin_float}, targets=move_targets
+                origin=gear_origin_float, targets=move_targets
             )
             await self.home_gear_motors()
 
@@ -2582,7 +2595,7 @@ class OT3API(
         mount: Union[top_types.Mount, OT3Mount],
         critical_point: Optional[CriticalPoint] = None,
     ) -> float:
-        carriage_pos = self._deck_from_machine(self._backend.home_position())
+        carriage_pos = self.get_deck_from_machine(self._backend.home_position())
         pos_at_home = self._effector_pos_from_carriage_pos(
             OT3Mount.from_mount(mount), carriage_pos, critical_point
         )
@@ -2664,10 +2677,9 @@ class OT3API(
         probe_settings: LiquidProbeSettings,
         probe: InstrumentProbeType,
         p_travel: float,
+        z_offset_for_plunger_prep: float,
         force_both_sensors: bool = False,
-        response_queue: Optional[
-            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
-        ] = None,
+        response_queue: Optional[PipetteSensorResponseQueue] = None,
     ) -> float:
         plunger_direction = -1 if probe_settings.aspirate_while_sensing else 1
         end_z = await self._backend.liquid_probe(
@@ -2678,13 +2690,14 @@ class OT3API(
             probe_settings.sensor_threshold_pascals,
             probe_settings.plunger_impulse_time,
             probe_settings.samples_for_baselining,
+            z_offset_for_plunger_prep,
             probe=probe,
             force_both_sensors=force_both_sensors,
             response_queue=response_queue,
         )
         machine_pos = await self._backend.update_position()
         machine_pos[Axis.by_mount(mount)] = end_z
-        deck_end_z = self._deck_from_machine(machine_pos)[Axis.by_mount(mount)]
+        deck_end_z = self.get_deck_from_machine(machine_pos)[Axis.by_mount(mount)]
         offset = offset_for_mount(
             mount,
             top_types.Point(*self._config.left_mount_offset),
@@ -2701,9 +2714,7 @@ class OT3API(
         probe_settings: Optional[LiquidProbeSettings] = None,
         probe: Optional[InstrumentProbeType] = None,
         force_both_sensors: bool = False,
-        response_queue: Optional[
-            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
-        ] = None,
+        response_queue: Optional[PipetteSensorResponseQueue] = None,
     ) -> float:
         """Search for and return liquid level height.
 
@@ -2829,6 +2840,7 @@ class OT3API(
                     probe_settings,
                     checked_probe,
                     plunger_travel_mm + sensor_baseline_plunger_move_mm,
+                    z_offset_for_plunger_prep,
                     force_both_sensors,
                     response_queue,
                 )

opentrons/hardware_control/protocols/gripper_controller.py

@@ -14,6 +14,9 @@ class GripperController(Protocol):
     ) -> None:
         ...
 
+    async def home_gripper_jaw(self) -> None:
+        ...
+
     async def ungrip(self, force_newtons: Optional[float] = None) -> None:
         """Release gripped object.
 

opentrons/hardware_control/protocols/hardware_manager.py

@@ -1,7 +1,7 @@
 from typing import Dict, Optional
 from typing_extensions import Protocol
 
-from ..types import SubSystem, SubSystemState
+from ..types import SubSystem, SubSystemState, Axis
 
 
 class HardwareManager(Protocol):
@@ -45,3 +45,7 @@ class HardwareManager(Protocol):
     async def get_serial_number(self) -> Optional[str]:
         """Get the robot serial number, if provisioned. If not provisioned, will be None."""
         ...
+
+    def axis_is_present(self, axis: Axis) -> bool:
+        """Get whether a motor axis is present on the machine."""
+        ...

opentrons/hardware_control/protocols/liquid_handler.py

@@ -1,6 +1,8 @@
 from typing import Optional
 from typing_extensions import Protocol
 
+from opentrons.types import Point
+from opentrons.hardware_control.types import CriticalPoint
 from .types import MountArgType, CalibrationType, ConfigType
 
 from .instrument_configurer import InstrumentConfigurer
@@ -16,6 +18,22 @@ class LiquidHandler(
     Calibratable[CalibrationType],
     Protocol[CalibrationType, MountArgType, ConfigType],
 ):
+    def critical_point_for(
+        self,
+        mount: MountArgType,
+        cp_override: Optional[CriticalPoint] = None,
+    ) -> Point:
+        """
+        Determine the current critical point for the specified mount.
+
+        :param mount: A robot mount that the instrument is on.
+        :param cp_override: The critical point override to use.
+
+        If no critical point override is specified, the robot defaults to nozzle location `A1` or the mount critical point.
+        :return: Point.
+        """
+        ...
+
     async def update_nozzle_configuration_for_mount(
         self,
         mount: MountArgType,

opentrons/hardware_control/protocols/motion_controller.py

@@ -9,6 +9,12 @@ from .types import MountArgType
 class MotionController(Protocol[MountArgType]):
     """Protocol specifying fundamental motion controls."""
 
+    def get_deck_from_machine(
+        self, machine_pos: Dict[Axis, float]
+    ) -> Dict[Axis, float]:
+        """Convert machine coordinates to deck coordinates."""
+        ...
+
     async def halt(self, disengage_before_stopping: bool = False) -> None:
         """Immediately stop motion.
 

opentrons/hardware_control/robot_calibration.py

@@ -154,7 +154,7 @@ def load_attitude_matrix() -> DeckCalibration:
         return DeckCalibration(
             attitude=calibration_data.attitude,
             source=calibration_data.source,
-            status=types.CalibrationStatus(**calibration_data.status.dict()),
+            status=types.CalibrationStatus(**calibration_data.status.model_dump()),
             last_modified=calibration_data.last_modified,
             pipette_calibrated_with=calibration_data.pipette_calibrated_with,
             tiprack=calibration_data.tiprack,

opentrons/hardware_control/types.py

@@ -1,3 +1,4 @@
+from asyncio import Queue
 import enum
 import logging
 from dataclasses import dataclass
@@ -712,3 +713,63 @@ class FailedTipStateCheck(RuntimeError):
         super().__init__(
             f"Expected tip state {expected_state}, but received {actual_state}."
         )
+
+
+@enum.unique
+class PipetteSensorId(int, enum.Enum):
+    """Sensor IDs available.
+
+    Not to be confused with SensorType. This is the ID value that separate
+    two or more of the same type of sensor within a system.
+
+    Note that this is a copy of an enum defined in opentrons_hardware.firmware_bindings.constants. That version
+    is authoritative; this version is here because this data is exposed above the hardware control layer and
+    therefore needs a typing source here so that we don't create a dependency on the internal hardware package.
+    """
+
+    S0 = 0x0
+    S1 = 0x1
+    UNUSED = 0x2
+    BOTH = 0x3
+
+
+@enum.unique
+class PipetteSensorType(int, enum.Enum):
+    """Sensor types available.
+
+    Note that this is a copy of an enum defined in opentrons_hardware.firmware_bindings.constants. That version
+    is authoritative; this version is here because this data is exposed above the hardware control layer and
+    therefore needs a typing source here so that we don't create a dependency on the internal hardware package.
+    """
+
+    tip = 0x00
+    capacitive = 0x01
+    environment = 0x02
+    pressure = 0x03
+    pressure_temperature = 0x04
+    humidity = 0x05
+    temperature = 0x06
+
+
+@dataclass(frozen=True)
+class PipetteSensorData:
+    """Sensor data from a monitored sensor.
+
+    Note that this is a copy of an enum defined in opentrons_hardware.firmware_bindings.constants. That version
+    is authoritative; this version is here because this data is exposed above the hardware control layer and
+    therefore needs a typing source here so that we don't create a dependency on the internal hardware package.
+    """
+
+    sensor_type: PipetteSensorType
+    _as_int: int
+    _as_float: float
+
+    def to_float(self) -> float:
+        return self._as_float
+
+    @property
+    def to_int(self) -> int:
+        return self._as_int
+
+
+PipetteSensorResponseQueue = Queue[Dict[PipetteSensorId, List[PipetteSensorData]]]

opentrons/protocol_api/__init__.py

@@ -30,7 +30,16 @@ from .module_contexts import (
 )
 from .disposal_locations import TrashBin, WasteChute
 from ._liquid import Liquid, LiquidClass
-from ._types import OFF_DECK
+from ._types import (
+    OFF_DECK,
+    PLUNGER_BLOWOUT,
+    PLUNGER_TOP,
+    PLUNGER_BOTTOM,
+    PLUNGER_DROPTIP,
+    ASPIRATE_ACTION,
+    DISPENSE_ACTION,
+    BLOWOUT_ACTION,
+)
 from ._nozzle_layout import (
     COLUMN,
     PARTIAL_COLUMN,
@@ -69,12 +78,22 @@ __all__ = [
     "Liquid",
     "LiquidClass",
     "Parameters",
+    # Partial Tip types
     "COLUMN",
     "PARTIAL_COLUMN",
     "SINGLE",
     "ROW",
     "ALL",
+    # Deck location types
     "OFF_DECK",
+    # Pipette plunger types
+    "PLUNGER_BLOWOUT",
+    "PLUNGER_TOP",
+    "PLUNGER_BOTTOM",
+    "PLUNGER_DROPTIP",
+    "ASPIRATE_ACTION",
+    "DISPENSE_ACTION",
+    "BLOWOUT_ACTION",
     "RuntimeParameterRequiredError",
     "CSVParameter",
     # For internal Opentrons use only:

opentrons/protocol_api/_liquid.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Optional, Sequence
+from typing import Optional, Dict
 
 from opentrons_shared_data.liquid_classes.liquid_class_definition import (
     LiquidClassSchemaV1,
-    AspirateProperties,
-    SingleDispenseProperties,
-    MultiDispenseProperties,
-    ByPipetteSetting,
-    ByTipTypeSetting,
+)
+
+from ._liquid_properties import (
+    TransferProperties,
+    build_transfer_properties,
 )
 
 
@@ -29,46 +31,29 @@ class Liquid:
     display_color: Optional[str]
 
 
-# TODO (spp, 2024-10-17): create PAPI-equivalent types for all the properties
-#  and have validation on value updates with user-facing error messages
-@dataclass
-class TransferProperties:
-    _aspirate: AspirateProperties
-    _dispense: SingleDispenseProperties
-    _multi_dispense: Optional[MultiDispenseProperties]
-
-    @property
-    def aspirate(self) -> AspirateProperties:
-        """Aspirate properties."""
-        return self._aspirate
-
-    @property
-    def dispense(self) -> SingleDispenseProperties:
-        """Single dispense properties."""
-        return self._dispense
-
-    @property
-    def multi_dispense(self) -> Optional[MultiDispenseProperties]:
-        """Multi dispense properties."""
-        return self._multi_dispense
-
-
 @dataclass
 class LiquidClass:
     """A data class that contains properties of a specific class of liquids."""
 
     _name: str
     _display_name: str
-    _by_pipette_setting: Sequence[ByPipetteSetting]
+    _by_pipette_setting: Dict[str, Dict[str, TransferProperties]]
 
     @classmethod
     def create(cls, liquid_class_definition: LiquidClassSchemaV1) -> "LiquidClass":
         """Liquid class factory method."""
 
+        by_pipette_settings: Dict[str, Dict[str, TransferProperties]] = {}
+        for by_pipette in liquid_class_definition.byPipette:
+            tip_settings: Dict[str, TransferProperties] = {}
+            for tip_type in by_pipette.byTipType:
+                tip_settings[tip_type.tiprack] = build_transfer_properties(tip_type)
+            by_pipette_settings[by_pipette.pipetteModel] = tip_settings
+
         return cls(
             _name=liquid_class_definition.liquidClassName,
             _display_name=liquid_class_definition.displayName,
-            _by_pipette_setting=liquid_class_definition.byPipette,
+            _by_pipette_setting=by_pipette_settings,
         )
 
     @property
@@ -81,26 +66,16 @@ class LiquidClass:
 
     def get_for(self, pipette: str, tiprack: str) -> TransferProperties:
         """Get liquid class transfer properties for the specified pipette and tip."""
-        settings_for_pipette: Sequence[ByPipetteSetting] = [
-            pip_setting
-            for pip_setting in self._by_pipette_setting
-            if pip_setting.pipetteModel == pipette
-        ]
-        if len(settings_for_pipette) == 0:
+        try:
+            settings_for_pipette = self._by_pipette_setting[pipette]
+        except KeyError:
             raise ValueError(
                 f"No properties found for {pipette} in {self._name} liquid class"
             )
-        settings_for_tip: Sequence[ByTipTypeSetting] = [
-            tip_setting
-            for tip_setting in settings_for_pipette[0].byTipType
-            if tip_setting.tiprack == tiprack
-        ]
-        if len(settings_for_tip) == 0:
+        try:
+            transfer_properties = settings_for_pipette[tiprack]
+        except KeyError:
             raise ValueError(
                 f"No properties found for {tiprack} in {self._name} liquid class"
             )
-        return TransferProperties(
-            _aspirate=settings_for_tip[0].aspirate,
-            _dispense=settings_for_tip[0].singleDispense,
-            _multi_dispense=settings_for_tip[0].multiDispense,
-        )
+        return transfer_properties