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

opentrons/drivers/absorbance_reader/hid_protocol.py

@@ -1,9 +1,11 @@
 from typing import (
     Dict,
+    Optional,
     Protocol,
     List,
     Literal,
     Tuple,
+    Union,
     runtime_checkable,
     TypeVar,
 )
@@ -11,42 +13,42 @@ from typing import (
 Response = TypeVar("Response")
 
 ErrorCodeNames = Literal[
-    "BYONOY_ERROR_NO_ERROR",
-    "BYONOY_ERROR_UNKNOWN_ERROR",
-    "BYONOY_ERROR_DEVICE_CLOSED",
-    "BYONOY_ERROR_INVALID_ARGUMENT",
-    "BYONOY_ERROR_NO_MEMORY",
-    "BYONOY_ERROR_UNSUPPORTED_OPERATION",
-    "BYONOY_ERROR_DEVICE_COMMUNICATION_FAILURE",
-    "BYONOY_ERROR_DEVICE_OPERATION_FAILED",
-    "BYONOY_ERROR_DEVICE_OPEN_PREFIX",
-    "BYONOY_ERROR_DEVICE_NOT_FOUND",
-    "BYONOY_ERROR_DEVICE_TOO_NEW",
-    "BYONOY_ERROR_DEVICE_ALREADY_OPEN",
-    "BYONOY_ERROR_FIRMWARE_UPDATE_ERROR_PREFIX",
-    "BYONOY_ERROR_FIRMWARE_UPDATE_FILE_NOT_FOUND",
-    "BYONOY_ERROR_FIRMWARE_UPDATE_FILE_NOT_VALID",
-    "BYONOY_ERROR_FIRMWARE_UPDATE_FAILED",
-    "BYONOY_ERROR_FILE_ERROR_PREFIX",
-    "BYONOY_ERROR_FILE_WRITE_ERROR",
-    "BYONOY_ERROR_MEASUTEMNT_ERROR_PREFIX",
-    "BYONOY_ERROR_MEASUTEMNT_SLOT_NOT_EMPTY",
-    "BYONOY_ERROR_NOT_INITIALIZED",
-    "BYONOY_ERROR_INTERNAL",
+    "NO_ERROR",
+    "UNKNOWN_ERROR",
+    "DEVICE_CLOSED",
+    "INVALID_ARGUMENT",
+    "NO_MEMORY",
+    "UNSUPPORTED_OPERATION",
+    "DEVICE_COMMUNICATION_FAILURE",
+    "DEVICE_OPERATION_FAILED",
+    "DEVICE_OPEN_PREFIX",
+    "DEVICE_NOT_FOUND",
+    "DEVICE_TOO_NEW",
+    "DEVICE_ALREADY_OPEN",
+    "FIRMWARE_UPDATE_ERROR_PREFIX",
+    "FIRMWARE_UPDATE_FILE_NOT_FOUND",
+    "FIRMWARE_UPDATE_FILE_NOT_VALID",
+    "FIRMWARE_UPDATE_FAILED",
+    "FILE_ERROR_PREFIX",
+    "FILE_WRITE_ERROR",
+    "MEASUTEMNT_ERROR_PREFIX",
+    "MEASUTEMNT_SLOT_NOT_EMPTY",
+    "NOT_INITIALIZED",
+    "INTERNAL",
 ]
 
 SlotStateNames = Literal[
-    "BYONOY_SLOT_UNKNOWN",
-    "BYONOY_SLOT_EMPTY",
-    "BYONOY_SLOT_OCCUPIED",
-    "BYONOY_SLOT_UNDETERMINED",
+    "UNKNOWN",
+    "EMPTY",
+    "OCCUPIED",
+    "UNDETERMINED",
 ]
 
 DeviceStateNames = Literal[
-    "BYONOY_DEVICE_STATE_UNKNOWN",
-    "BYONOY_DEVICE_STATE_OK",
-    "BYONOY_DEVICE_STATE_BROKEN_FW",
-    "BYONOY_DEVICE_STATE_ERROR",
+    "UNKNOWN",
+    "OK",
+    "BROKEN_FW",
+    "ERROR",
 ]
 
 
@@ -69,8 +71,13 @@ class AbsorbanceHidInterface(Protocol):
         value: int
 
     @runtime_checkable
-    class MeasurementConfig(Protocol):
+    class SingleMeasurementConfig(Protocol):
         sample_wavelength: int
+        reference_wavelength: Optional[int]
+
+    @runtime_checkable
+    class MultiMeasurementConfig(Protocol):
+        sample_wavelengths: List[int]
 
     @runtime_checkable
     class DeviceInfo(Protocol):
@@ -84,49 +91,71 @@ class AbsorbanceHidInterface(Protocol):
         name: DeviceStateNames
         value: int
 
-    def ByonoyAbs96SingleMeasurementConfig(self) -> MeasurementConfig:
+    def Abs96SingleMeasurementConfig(self) -> SingleMeasurementConfig:
+        ...
+
+    def Abs96MultipleMeasurementConfig(self) -> MultiMeasurementConfig:
+        ...
+
+    def open_device(self, device: Device) -> Tuple[ErrorCode, int]:
         ...
 
-    def byonoy_open_device(self, device: Device) -> Tuple[ErrorCode, int]:
+    def free_device(self, device_handle: int) -> Tuple[ErrorCode, bool]:
         ...
 
-    def byonoy_free_device(self, device_handle: int) -> Tuple[ErrorCode, bool]:
+    def device_open(self, device_handle: int) -> bool:
         ...
 
-    def byonoy_get_device_information(
+    def get_device_information(
         self, device_handle: int
     ) -> Tuple[ErrorCode, DeviceInfo]:
         ...
 
-    def byonoy_get_device_status(
-        self, device_handle: int
-    ) -> Tuple[ErrorCode, DeviceState]:
+    def update_device(self, device_handle: int, firmware_file_path: str) -> ErrorCode:
         ...
 
-    def byonoy_get_device_slot_status(
-        self, device_handle: int
-    ) -> Tuple[ErrorCode, SlotState]:
+    def get_device_status(self, device_handle: int) -> Tuple[ErrorCode, DeviceState]:
         ...
 
-    def byonoy_get_device_parts_aligned(
-        self, device_handle: int
-    ) -> Tuple[ErrorCode, bool]:
+    def get_device_uptime(self, device_handle: int) -> Tuple[ErrorCode, int]:
+        ...
+
+    def get_device_slot_status(self, device_handle: int) -> Tuple[ErrorCode, SlotState]:
         ...
 
-    def byonoy_abs96_get_available_wavelengths(
+    def get_device_parts_aligned(self, device_handle: int) -> Tuple[ErrorCode, bool]:
+        ...
+
+    def abs96_get_available_wavelengths(
         self, device_handle: int
     ) -> Tuple[ErrorCode, List[int]]:
         ...
 
-    def byonoy_abs96_initialize_single_measurement(
-        self, device_handle: int, conf: MeasurementConfig
+    def abs96_initialize_single_measurement(
+        self, device_handle: int, conf: SingleMeasurementConfig
+    ) -> ErrorCode:
+        ...
+
+    def abs96_initialize_multiple_measurement(
+        self, device_handle: int, conf: MultiMeasurementConfig
     ) -> ErrorCode:
         ...
 
-    def byonoy_abs96_single_measure(
-        self, device_handle: int, conf: MeasurementConfig
+    def abs96_single_measure(
+        self, device_handle: int, conf: SingleMeasurementConfig
     ) -> Tuple[ErrorCode, List[float]]:
         ...
 
-    def byonoy_available_devices(self) -> List[Device]:
+    def abs96_multiple_measure(
+        self, device_handle: int, conf: MultiMeasurementConfig
+    ) -> Tuple[ErrorCode, List[List[float]]]:
         ...
+
+    def available_devices(self) -> List[Device]:
+        ...
+
+
+MeasurementConfig = Union[
+    AbsorbanceHidInterface.SingleMeasurementConfig,
+    AbsorbanceHidInterface.MultiMeasurementConfig,
+]

opentrons/drivers/absorbance_reader/simulator.py

@@ -1,18 +1,27 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 from opentrons.util.async_helpers import ensure_yield
 
 from opentrons.drivers.types import (
+    ABSMeasurementMode,
     AbsorbanceReaderLidStatus,
     AbsorbanceReaderDeviceState,
+    AbsorbanceReaderPlatePresence,
 )
 
 from .abstract import AbstractAbsorbanceReaderDriver
 
 
 class SimulatingDriver(AbstractAbsorbanceReaderDriver):
-    def __init__(self, serial_number: Optional[str] = None) -> None:
+    def __init__(
+        self, model: Optional[str] = None, serial_number: Optional[str] = None
+    ) -> None:
+        self._lid_status = AbsorbanceReaderLidStatus.ON
+        self._model = model if model else "absorbanceReaderV1"
         self._serial_number = serial_number
 
+    def model(self) -> str:
+        return self._model
+
     @ensure_yield
     async def get_device_info(self) -> Dict[str, str]:
         """Get device info"""
@@ -39,20 +48,37 @@ class SimulatingDriver(AbstractAbsorbanceReaderDriver):
 
     @ensure_yield
     async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
-        return AbsorbanceReaderLidStatus.ON
+        return self._lid_status
 
     @ensure_yield
     async def get_available_wavelengths(self) -> List[int]:
         return [450, 570, 600, 650]
 
     @ensure_yield
-    async def get_single_measurement(self, wavelength: int) -> List[float]:
-        return [0.0]
+    async def get_measurement(self) -> List[List[float]]:
+        return [[0.0]]
 
     @ensure_yield
-    async def initialize_measurement(self, wavelength: int) -> None:
+    async def initialize_measurement(
+        self,
+        wavelengths: List[int],
+        mode: ABSMeasurementMode = ABSMeasurementMode.SINGLE,
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
         pass
 
+    @ensure_yield
+    async def get_uptime(self) -> int:
+        return 10
+
+    @ensure_yield
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        return True, ""
+
     @ensure_yield
     async def get_status(self) -> AbsorbanceReaderDeviceState:
         return AbsorbanceReaderDeviceState.OK
+
+    @ensure_yield
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        return AbsorbanceReaderPlatePresence.PRESENT

opentrons/drivers/types.py

@@ -1,6 +1,6 @@
 """ Type definitions for modules in this tree """
 from dataclasses import dataclass
-from typing import Dict, NamedTuple, Optional
+from typing import Any, Dict, List, NamedTuple, Optional
 from enum import Enum
 
 
@@ -83,3 +83,25 @@ class AbsorbanceReaderDeviceState(str, Enum):
     OK = "ok"
     BROKEN_FW = "broken_fw"
     ERROR = "error"
+
+
+class ABSMeasurementMode(Enum):
+    """The current mode configured for reading the Absorbance Reader."""
+
+    SINGLE = "single"
+    MULTI = "multi"
+
+
+@dataclass
+class ABSMeasurementConfig:
+    measure_mode: ABSMeasurementMode
+    sample_wavelengths: List[int]
+    reference_wavelength: Optional[int]
+
+    @property
+    def data(self) -> Dict[str, Any]:
+        return {
+            "measureMode": self.measure_mode.value,
+            "sampleWavelengths": self.sample_wavelengths,
+            "referenceWavelength": self.reference_wavelength,
+        }

opentrons/execute.py

@@ -546,6 +546,7 @@ def _create_live_context_pe(
             hardware_api=hardware_api_wrapped,
             config=_get_protocol_engine_config(),
             deck_configuration=entrypoint_util.get_deck_configuration(),
+            file_provider=None,
             error_recovery_policy=error_recovery_policy.never_recover,
             drop_tips_after_run=False,
             post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
@@ -609,8 +610,6 @@ def _run_file_non_pe(
 
     context.home()
     try:
-        # TODO (spp, 2024-03-18): use true run-time param overrides once enabled
-        #  for cli protocol simulation/ execution
         execute_apiv2.run_protocol(
             protocol, context, run_time_parameters_with_overrides=None
         )
@@ -626,6 +625,7 @@ def _run_file_pe(
     """Run a protocol file with Protocol Engine."""
 
     async def run(protocol_source: ProtocolSource) -> None:
+        # TODO (spp, 2024-03-18): use run-time param overrides once enabled for cli protocol execution
         hardware_api_wrapped = hardware_api.wrapped()
         protocol_engine = await create_protocol_engine(
             hardware_api=hardware_api_wrapped,

opentrons/hardware_control/api.py

@@ -1189,11 +1189,6 @@ class API(
 
         await self.retract(mount, spec.retract_target)
 
-    def cache_tip(self, mount: top_types.Mount, tip_length: float) -> None:
-        instrument = self.get_pipette(mount)
-        instrument.add_tip(tip_length=tip_length)
-        instrument.set_current_volume(0)
-
     async def pick_up_tip(
         self,
         mount: top_types.Mount,
@@ -1241,10 +1236,10 @@ class API(
         if prep_after:
             await self.prepare_for_aspirate(mount)
 
-    async def drop_tip(self, mount: top_types.Mount, home_after: bool = True) -> None:
-        """Drop tip at the current location."""
-
-        spec, _remove = self.plan_check_drop_tip(mount, home_after)
+    async def tip_drop_moves(
+        self, mount: top_types.Mount, home_after: bool = True
+    ) -> None:
+        spec, _ = self.plan_check_drop_tip(mount, home_after)
 
         for move in spec.drop_moves:
             self._backend.set_active_current(move.current)
@@ -1272,7 +1267,20 @@ class API(
             await self.move_rel(mount, shake[0], speed=shake[1])
 
         self._backend.set_active_current(spec.ending_current)
-        _remove()
+
+    async def drop_tip(self, mount: top_types.Mount, home_after: bool = True) -> None:
+        """Drop tip at the current location."""
+        await self.tip_drop_moves(mount, home_after)
+
+        # todo(mm, 2024-10-17): Ideally, callers would be able to replicate the behavior
+        # of this method via self.drop_tip_moves() plus other public methods. This
+        # currently prevents that: there is no public equivalent for
+        # instrument.set_current_volume().
+        instrument = self.get_pipette(mount)
+        instrument.set_current_volume(0)
+
+        self.set_current_tiprack_diameter(mount, 0.0)
+        self.remove_tip(mount)
 
     async def create_simulating_module(
         self,

opentrons/hardware_control/backends/controller.py

@@ -57,7 +57,7 @@ class Controller:
     """
 
     @classmethod
-    async def build(cls, config: RobotConfig) -> Controller:
+    async def build(cls, config: Optional[RobotConfig]) -> Controller:
         """Build a Controller instance.
 
         Use this factory method rather than the initializer to handle proper
@@ -65,12 +65,13 @@ class Controller:
 
         :param config: A loaded robot config.
         """
+
         gpio = build_gpio_chardev("gpiochip0")
         gpio.config_by_board_rev()
         await gpio.setup()
         return cls(config, gpio)
 
-    def __init__(self, config: RobotConfig, gpio: GPIODriverLike):
+    def __init__(self, config: Optional[RobotConfig], gpio: GPIODriverLike):
         """Build a Controller instance.
 
         Always prefer using :py:meth:`.build` to create an instance of this class. For

opentrons/hardware_control/backends/flex_protocol.py

@@ -15,7 +15,7 @@ from typing import (
 from opentrons_shared_data.pipette.types import (
     PipetteName,
 )
-from opentrons.config.types import GantryLoad, OutputOptions
+from opentrons.config.types import GantryLoad
 from opentrons.hardware_control.types import (
     BoardRevision,
     Axis,
@@ -38,6 +38,8 @@ from opentrons.hardware_control.types import (
     StatusBarState,
 )
 from opentrons.hardware_control.module_control import AttachedModulesControl
+from opentrons_hardware.firmware_bindings.constants import SensorId
+from opentrons_hardware.sensors.types import SensorDataType
 from ..dev_types import OT3AttachedInstruments
 from .types import HWStopCondition
 
@@ -54,6 +56,10 @@ class FlexBackend(Protocol):
     def restore_system_constraints(self) -> AsyncIterator[None]:
         ...
 
+    @asynccontextmanager
+    def grab_pressure(self, channels: int, mount: OT3Mount) -> AsyncIterator[None]:
+        ...
+
     def update_constraints_for_gantry_load(self, gantry_load: GantryLoad) -> None:
         ...
 
@@ -147,10 +153,12 @@ class FlexBackend(Protocol):
         plunger_speed: float,
         threshold_pascals: float,
         plunger_impulse_time: float,
-        output_format: OutputOptions = OutputOptions.can_bus_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
+        num_baseline_reads: int,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         ...
 
@@ -366,8 +374,6 @@ class FlexBackend(Protocol):
         speed_mm_per_s: float,
         sensor_threshold_pf: float,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
-        output_format: OutputOptions = OutputOptions.sync_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
     ) -> bool:
         ...
 

opentrons/hardware_control/backends/ot3controller.py

@@ -25,7 +25,7 @@ from typing import (
     Union,
     Mapping,
 )
-from opentrons.config.types import OT3Config, GantryLoad, OutputOptions
+from opentrons.config.types import OT3Config, GantryLoad
 from opentrons.config import gripper_config
 from .ot3utils import (
     axis_convert,
@@ -102,7 +102,9 @@ from opentrons_hardware.firmware_bindings.constants import (
     NodeId,
     PipetteName as FirmwarePipetteName,
     ErrorCode,
+    SensorId,
 )
+from opentrons_hardware.sensors.types import SensorDataType
 from opentrons_hardware.firmware_bindings.messages.message_definitions import (
     StopRequest,
 )
@@ -161,6 +163,7 @@ from opentrons_hardware.hardware_control.tool_sensors import (
     capacitive_pass,
     liquid_probe,
     check_overpressure,
+    grab_pressure,
 )
 from opentrons_hardware.hardware_control.rear_panel_settings import (
     get_door_state,
@@ -369,6 +372,14 @@ class OT3Controller(FlexBackend):
             self._move_manager.update_constraints(old_system_constraints)
             log.debug(f"Restore previous system constraints: {old_system_constraints}")
 
+    @asynccontextmanager
+    async def grab_pressure(
+        self, channels: int, mount: OT3Mount
+    ) -> AsyncIterator[None]:
+        tool = axis_to_node(Axis.of_main_tool_actuator(mount))
+        async with grab_pressure(channels, tool, self._messenger):
+            yield
+
     def update_constraints_for_calibration_with_gantry_load(
         self,
         gantry_load: GantryLoad,
@@ -1358,28 +1369,15 @@ class OT3Controller(FlexBackend):
         plunger_speed: float,
         threshold_pascals: float,
         plunger_impulse_time: float,
-        output_option: OutputOptions = OutputOptions.can_bus_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
+        num_baseline_reads: int,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         head_node = axis_to_node(Axis.by_mount(mount))
         tool = sensor_node_for_pipette(OT3Mount(mount.value))
-        csv_output = bool(output_option.value & OutputOptions.stream_to_csv.value)
-        sync_buffer_output = bool(
-            output_option.value & OutputOptions.sync_buffer_to_csv.value
-        )
-        can_bus_only_output = bool(
-            output_option.value & OutputOptions.can_bus_only.value
-        )
-        data_files_transposed = (
-            None
-            if data_files is None
-            else {
-                sensor_id_for_instrument(probe): data_files[probe]
-                for probe in data_files.keys()
-            }
-        )
         positions = await liquid_probe(
             messenger=self._messenger,
             tool=tool,
@@ -1389,12 +1387,10 @@ class OT3Controller(FlexBackend):
             mount_speed=mount_speed,
             threshold_pascals=threshold_pascals,
             plunger_impulse_time=plunger_impulse_time,
-            csv_output=csv_output,
-            sync_buffer_output=sync_buffer_output,
-            can_bus_only_output=can_bus_only_output,
-            data_files=data_files_transposed,
+            num_baseline_reads=num_baseline_reads,
             sensor_id=sensor_id_for_instrument(probe),
             force_both_sensors=force_both_sensors,
+            response_queue=response_queue,
         )
         for node, point in positions.items():
             self._position.update({node: point.motor_position})
@@ -1421,41 +1417,13 @@ class OT3Controller(FlexBackend):
         speed_mm_per_s: float,
         sensor_threshold_pf: float,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
-        output_option: OutputOptions = OutputOptions.sync_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
     ) -> bool:
-        if output_option == OutputOptions.sync_buffer_to_csv:
-            assert (
-                self._subsystem_manager.device_info[
-                    SubSystem.of_mount(mount)
-                ].revision.tertiary
-                == "1"
-            )
-        csv_output = bool(output_option.value & OutputOptions.stream_to_csv.value)
-        sync_buffer_output = bool(
-            output_option.value & OutputOptions.sync_buffer_to_csv.value
-        )
-        can_bus_only_output = bool(
-            output_option.value & OutputOptions.can_bus_only.value
-        )
-        data_files_transposed = (
-            None
-            if data_files is None
-            else {
-                sensor_id_for_instrument(probe): data_files[probe]
-                for probe in data_files.keys()
-            }
-        )
         status = await capacitive_probe(
             messenger=self._messenger,
             tool=sensor_node_for_mount(mount),
             mover=axis_to_node(moving),
             distance=distance_mm,
             mount_speed=speed_mm_per_s,
-            csv_output=csv_output,
-            sync_buffer_output=sync_buffer_output,
-            can_bus_only_output=can_bus_only_output,
-            data_files=data_files_transposed,
             sensor_id=sensor_id_for_instrument(probe),
             relative_threshold_pf=sensor_threshold_pf,
         )

opentrons/hardware_control/backends/ot3simulator.py

@@ -17,7 +17,7 @@ from typing import (
     Mapping,
 )
 
-from opentrons.config.types import OT3Config, GantryLoad, OutputOptions
+from opentrons.config.types import OT3Config, GantryLoad
 from opentrons.config import gripper_config
 
 from opentrons.hardware_control.module_control import AttachedModulesControl
@@ -63,7 +63,8 @@ from opentrons.hardware_control.dev_types import (
 from opentrons.util.async_helpers import ensure_yield
 from .types import HWStopCondition
 from .flex_protocol import FlexBackend
-
+from opentrons_hardware.firmware_bindings.constants import SensorId
+from opentrons_hardware.sensors.types import SensorDataType
 
 log = logging.getLogger(__name__)
 
@@ -346,10 +347,12 @@ class OT3Simulator(FlexBackend):
         plunger_speed: float,
         threshold_pascals: float,
         plunger_impulse_time: float,
-        output_format: OutputOptions = OutputOptions.can_bus_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
+        num_baseline_reads: int,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         z_axis = Axis.by_mount(mount)
         pos = self._position
@@ -749,8 +752,6 @@ class OT3Simulator(FlexBackend):
         speed_mm_per_s: float,
         sensor_threshold_pf: float,
         probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
-        output_format: OutputOptions = OutputOptions.sync_only,
-        data_files: Optional[Dict[InstrumentProbeType, str]] = None,
     ) -> bool:
         self._position[moving] += distance_mm
         return True