opentrons 8.3.1a1__py2.py3-none-any.whl → 8.4.0a1__py2.py3-none-any.whl

opentrons/calibration_storage/ot2/mark_bad_calibration.py

@@ -10,7 +10,9 @@ from .models import v1
 CalibrationType = typing.TypeVar(
     "CalibrationType",
     v1.PipetteOffsetCalibration,
+    v1.InstrumentOffsetModel,
     v1.TipLengthCalibration,
+    v1.TipLengthModel,
     v1.DeckCalibrationModel,
 )
 

opentrons/calibration_storage/ot2/tip_length.py

@@ -16,7 +16,7 @@ from opentrons.util.helpers import utc_now
 from .models import v1
 
 if typing.TYPE_CHECKING:
-    from opentrons_shared_data.labware.types import LabwareDefinition
+    from opentrons_shared_data.labware.types import LabwareDefinition2
 
 
 log = logging.getLogger(__name__)
@@ -78,7 +78,7 @@ def tip_lengths_for_pipette(
 
 
 def load_tip_length_calibration(
-    pip_id: str, definition: "LabwareDefinition"
+    pip_id: str, definition: "LabwareDefinition2"
 ) -> v1.TipLengthModel:
     """
     Function used to grab the current tip length associated
@@ -127,7 +127,7 @@ def get_all_tip_length_calibrations() -> typing.List[v1.TipLengthCalibration]:
     return all_tip_lengths_available
 
 
-def get_custom_tiprack_definition_for_tlc(labware_uri: str) -> "LabwareDefinition":
+def get_custom_tiprack_definition_for_tlc(labware_uri: str) -> "LabwareDefinition2":
     """
     Return the custom tiprack definition saved in the custom tiprack directory
     during tip length calibration
@@ -137,7 +137,7 @@ def get_custom_tiprack_definition_for_tlc(labware_uri: str) -> "LabwareDefinitio
     try:
         with open(custom_tiprack_path, "rb") as f:
             return typing.cast(
-                "LabwareDefinition",
+                "LabwareDefinition2",
                 json.loads(f.read().decode("utf-8")),
             )
     except FileNotFoundError:
@@ -213,7 +213,7 @@ def clear_tip_length_calibration() -> None:
 
 
 def create_tip_length_data(
-    definition: "LabwareDefinition",
+    definition: "LabwareDefinition2",
     length: float,
     cal_status: typing.Optional[
         typing.Union[local_types.CalibrationStatus, v1.CalibrationStatus]
@@ -251,7 +251,7 @@ def create_tip_length_data(
 
 def _save_custom_tiprack_definition(
     labware_uri: str,
-    definition: "LabwareDefinition",
+    definition: "LabwareDefinition2",
 ) -> None:
     namespace, load_name, version = labware_uri.split("/")
     custom_tr_dir_path = config.get_custom_tiprack_def_path()

opentrons/config/advanced_settings.py

@@ -222,17 +222,6 @@ settings = [
         robot_type=[RobotTypeEnum.OT2, RobotTypeEnum.FLEX],
         internal_only=True,
     ),
-    SettingDefinition(
-        _id="allowLiquidClasses",
-        title="Allow the use of liquid classes",
-        description=(
-            "Do not enable."
-            " This is an Opentrons internal setting to allow using in-development"
-            " liquid classes."
-        ),
-        robot_type=[RobotTypeEnum.OT2, RobotTypeEnum.FLEX],
-        internal_only=True,
-    ),
 ]
 
 
@@ -736,6 +725,14 @@ def _migrate35to36(previous: SettingsMap) -> SettingsMap:
     return newmap
 
 
+def _migrate36to37(previous: SettingsMap) -> SettingsMap:
+    """Migrate to version 37 of the feature flags file.
+
+    - Removes the allowLiquidClasses flag.
+    """
+    return {k: v for k, v in previous.items() if "allowLiquidClasses" != k}
+
+
 _MIGRATIONS = [
     _migrate0to1,
     _migrate1to2,
@@ -773,6 +770,7 @@ _MIGRATIONS = [
     _migrate33to34,
     _migrate34to35,
     _migrate35to36,
+    _migrate36to37,
 ]
 """
 List of all migrations to apply, indexed by (version - 1). See _migrate below

opentrons/config/feature_flags.py

@@ -78,7 +78,3 @@ def enable_performance_metrics(robot_type: RobotTypeEnum) -> bool:
 
 def oem_mode_enabled() -> bool:
     return advs.get_setting_with_env_overload("enableOEMMode", RobotTypeEnum.FLEX)
-
-
-def allow_liquid_classes(robot_type: RobotTypeEnum) -> bool:
-    return advs.get_setting_with_env_overload("allowLiquidClasses", robot_type)

opentrons/config/reset.py

@@ -90,8 +90,13 @@ _settings_reset_options = {
     # This option is defined here only as a convenience for robot-server.
     # Find a way to split things up and define this in robot-server instead.
     ResetOptionId.runs_history: CommonResetOption(
-        name="Clear Runs History",
-        description="Erase this device's stored history of protocols and runs.",
+        name="Clear Robot Server Data",
+        description=(
+            "Erase everything stored by the robot server. This is *not* everything stored"
+            " on the robot. It currently includes runs, protocols, labware offsets, and more,"
+            " and the exact list may change over time. This is exposed for troubleshooting"
+            " and system recovery. The name `runsHistory` is a misnomer, for historical reasons."
+        ),
     ),
     ResetOptionId.on_device_display: CommonResetOption(
         name="On-Device Display Configuration",

opentrons/drivers/asyncio/communication/__init__.py

@@ -5,6 +5,7 @@ from opentrons.drivers.asyncio.communication.errors import (
     AlarmResponse,
     ErrorResponse,
     UnhandledGcode,
+    DefaultErrorCodes,
 )
 from .async_serial import AsyncSerial
 
@@ -17,4 +18,5 @@ __all__ = [
     "AlarmResponse",
     "ErrorResponse",
     "UnhandledGcode",
+    "DefaultErrorCodes",
 ]

opentrons/drivers/asyncio/communication/async_serial.py

@@ -155,6 +155,10 @@ class AsyncSerial:
         """Reset the input buffer"""
         self._serial.reset_input_buffer()
 
+    def reset_output_buffer(self) -> None:
+        """Reset the output buffer"""
+        self._serial.reset_output_buffer()
+
     @contextlib.asynccontextmanager
     async def timeout_override(
         self, timeout_property: TimeoutProperties, timeout: Optional[float]

opentrons/drivers/asyncio/communication/errors.py

@@ -1,11 +1,7 @@
 """Errors raised by serial connection."""
 
-
 from enum import Enum
-
-
-class ErrorCodes(Enum):
-    UNHANDLED_GCODE = "ERR003"
+from typing import Dict, Type, Optional
 
 
 class SerialException(Exception):
@@ -36,10 +32,47 @@ class AlarmResponse(FailedCommand):
 
 
 class ErrorResponse(FailedCommand):
-    pass
+    def __init__(self, port: str, response: str, command: Optional[str] = None) -> None:
+        super().__init__(port, response)
+        self.command = command
 
 
 class UnhandledGcode(ErrorResponse):
     def __init__(self, port: str, response: str, command: str) -> None:
-        self.command = command
-        super().__init__(port, response)
+        super().__init__(port, response, command)
+
+
+class BaseErrorCode(Enum):
+    """Base class for error code enums.
+
+    This class should be inherited to define specific sets of error codes.
+    """
+
+    @property
+    def code_string(self) -> str:
+        """Return the error code string."""
+        code: str = self.value[0]
+        return code.lower()
+
+    @property
+    def exception(self) -> Type[ErrorResponse]:
+        """Return the exception class associated with this error code."""
+        exc: Type[ErrorResponse] = self.value[1]
+        return exc
+
+    def raise_exception(self, port: str, response: str, command: str) -> None:
+        """Raise the appropriate exception for this error code."""
+        raise self.exception(port=port, response=response, command=command)
+
+    @classmethod
+    def get_error_codes(cls) -> Dict[str, "BaseErrorCode"]:
+        """Get all error codes as a dictionary mapping code string to ErrorCode instance."""
+        return {code.code_string: code for code in cls}
+
+
+class DefaultErrorCodes(BaseErrorCode):
+    """
+    Default error codes that are previously handled by the SerialConnection class.
+    """
+
+    UNHANDLED_GCODE = ("ERR003", UnhandledGcode)

opentrons/drivers/asyncio/communication/serial_connection.py

@@ -2,11 +2,17 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, List
+from typing import Optional, List, Type
 
 from opentrons.drivers.command_builder import CommandBuilder
 
-from .errors import NoResponse, AlarmResponse, ErrorResponse, UnhandledGcode, ErrorCodes
+from .errors import (
+    NoResponse,
+    AlarmResponse,
+    ErrorResponse,
+    BaseErrorCode,
+    DefaultErrorCodes,
+)
 from .async_serial import AsyncSerial
 
 log = logging.getLogger(__name__)
@@ -43,7 +49,8 @@ class SerialConnection:
         error_keyword: Optional[str] = None,
         alarm_keyword: Optional[str] = None,
         reset_buffer_before_write: bool = False,
-    ) -> SerialConnection:
+        error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
+    ) -> "SerialConnection":
         """
         Create a connection.
 
@@ -63,6 +70,8 @@ class SerialConnection:
                            (default: alarm)
             reset_buffer_before_write: whether to reset the read buffer before
               every write
+            error_codes: Enum class for error codes
+                         (default: DefaultErrorCodes)
 
         Returns: SerialConnection
         """
@@ -82,6 +91,7 @@ class SerialConnection:
             retry_wait_time_seconds=retry_wait_time_seconds,
             error_keyword=error_keyword or "error",
             alarm_keyword=alarm_keyword or "alarm",
+            error_codes=error_codes,
         )
 
     def __init__(
@@ -93,6 +103,7 @@ class SerialConnection:
         retry_wait_time_seconds: float,
         error_keyword: str,
         alarm_keyword: str,
+        error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
     ) -> None:
         """
         Constructor
@@ -107,6 +118,7 @@ class SerialConnection:
                            exception when detected
             alarm_keyword: string that will cause an AlarmResponse
                            exception when detected
+            error_codes: Enum class for error codes
         """
         self._serial = serial
         self._port = port
@@ -116,6 +128,7 @@ class SerialConnection:
         self._send_data_lock = asyncio.Lock()
         self._error_keyword = error_keyword.lower()
         self._alarm_keyword = alarm_keyword.lower()
+        self._error_codes = error_codes
 
     async def send_command(
         self, command: CommandBuilder, retries: int = 0, timeout: Optional[float] = None
@@ -237,8 +250,8 @@ class SerialConnection:
         Raise an error if the response contains an error
 
         Args:
-            gcode: the requesting gocde
             response: response
+            request: the requesting command
 
         Returns: None
 
@@ -250,12 +263,16 @@ class SerialConnection:
             raise AlarmResponse(port=self._port, response=response)
 
         if self._error_keyword.lower() in lower:
-            if ErrorCodes.UNHANDLED_GCODE.value.lower() in lower:
-                raise UnhandledGcode(
-                    port=self._port, response=response, command=request
-                )
-            else:
-                raise ErrorResponse(port=self._port, response=response)
+            # Check for specific error codes
+            error_codes_dict = self._error_codes.get_error_codes()
+            for code, error_code in error_codes_dict.items():
+                if code in lower:
+                    error_code.raise_exception(
+                        port=self._port, response=response, command=request
+                    )
+
+            # If no specific error code was found, raise a generic ErrorResponse
+            raise ErrorResponse(port=self._port, response=response)
 
     async def on_retry(self) -> None:
         """
@@ -297,6 +314,7 @@ class AsyncResponseSerialConnection(SerialConnection):
         error_keyword: Optional[str] = None,
         alarm_keyword: Optional[str] = None,
         reset_buffer_before_write: bool = False,
+        error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
         async_error_ack: Optional[str] = None,
         number_of_retries: int = 0,
     ) -> AsyncResponseSerialConnection:
@@ -321,6 +339,9 @@ class AsyncResponseSerialConnection(SerialConnection):
               every write
             async_error_ack: optional string that will indicate an asynchronous
                              error when detected (default: async)
+            number_of_retries: default number of retries
+            error_codes: Enum class for error codes
+                         (default: DefaultErrorCodes)
 
         Returns: AsyncResponseSerialConnection
         """
@@ -342,6 +363,7 @@ class AsyncResponseSerialConnection(SerialConnection):
             alarm_keyword=alarm_keyword or "alarm",
             async_error_ack=async_error_ack or "async",
             number_of_retries=number_of_retries,
+            error_codes=error_codes,
         )
 
     def __init__(
@@ -355,6 +377,7 @@ class AsyncResponseSerialConnection(SerialConnection):
         alarm_keyword: str,
         async_error_ack: str,
         number_of_retries: int = 0,
+        error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
     ) -> None:
         """
         Constructor
@@ -371,6 +394,8 @@ class AsyncResponseSerialConnection(SerialConnection):
                            exception when detected
             async_error_ack: string that will indicate an asynchronous
                              error when detected
+            number_of_retries: default number of retries
+            error_codes: Enum class for error codes
         """
         super().__init__(
             serial=serial,
@@ -380,6 +405,7 @@ class AsyncResponseSerialConnection(SerialConnection):
             retry_wait_time_seconds=retry_wait_time_seconds,
             error_keyword=error_keyword,
             alarm_keyword=alarm_keyword,
+            error_codes=error_codes,
         )
         self._serial = serial
         self._port = port

opentrons/drivers/flex_stacker/__init__.py

@@ -1,9 +1,15 @@
-from .abstract import AbstractStackerDriver
-from .driver import FlexStackerDriver
+from .abstract import AbstractFlexStackerDriver
+from .driver import FlexStackerDriver, STACKER_MOTION_CONFIG, STALLGUARD_CONFIG
 from .simulator import SimulatingDriver
+from . import types as FlexStackerTypes
+from . import utils as FlexStackerUtils
 
 __all__ = [
-    "AbstractStackerDriver",
+    "AbstractFlexStackerDriver",
     "FlexStackerDriver",
     "SimulatingDriver",
+    "FlexStackerTypes",
+    "FlexStackerUtils",
+    "STACKER_MOTION_CONFIG",
+    "STALLGUARD_CONFIG",
 ]

opentrons/drivers/flex_stacker/abstract.py

@@ -1,16 +1,28 @@
-from typing import Protocol
+from typing import List, Optional, Protocol
 
 from .types import (
+    ActiveRange,
+    LEDPattern,
+    LimitSwitchStatus,
+    MeasurementKind,
+    MoveResult,
+    SpadMapID,
     StackerAxis,
     PlatformStatus,
     Direction,
     MoveParams,
     StackerInfo,
     LEDColor,
+    StallGuardParams,
+    TOFConfiguration,
+    TOFMeasurement,
+    TOFMeasurementResult,
+    TOFSensor,
+    TOFSensorStatus,
 )
 
 
-class AbstractStackerDriver(Protocol):
+class AbstractFlexStackerDriver(Protocol):
     """Protocol for the Stacker driver."""
 
     async def connect(self) -> None:
@@ -25,22 +37,110 @@ class AbstractStackerDriver(Protocol):
         """Check connection to stacker."""
         ...
 
-    async def update_firmware(self, firmware_file_path: str) -> None:
-        """Updates the firmware on the device."""
-        ...
-
     async def get_device_info(self) -> StackerInfo:
         """Get Device Info."""
         ...
 
-    async def set_serial_number(self, sn: str) -> bool:
+    async def set_serial_number(self, sn: str) -> None:
         """Set Serial Number."""
         ...
 
-    async def stop_motors(self) -> bool:
+    async def enable_motors(self, axis: List[StackerAxis]) -> None:
+        """Enables the axis motor if present, disables it otherwise."""
+        ...
+
+    async def stop_motors(self) -> None:
         """Stop all motor movement."""
         ...
 
+    async def set_run_current(self, axis: StackerAxis, current: float) -> None:
+        """Set axis peak run current in amps."""
+        ...
+
+    async def set_ihold_current(self, axis: StackerAxis, current: float) -> None:
+        """Set axis hold current in amps."""
+        ...
+
+    async def set_stallguard_threshold(
+        self, axis: StackerAxis, enable: bool, threshold: int
+    ) -> None:
+        """Enables and sets the stallguard threshold for the given axis motor."""
+        ...
+
+    async def enable_tof_sensor(self, sensor: TOFSensor, enable: bool) -> None:
+        """Enable or disable the TOF sensor."""
+        ...
+
+    async def manage_tof_measurement(
+        self,
+        sensor: TOFSensor,
+        kind: MeasurementKind = MeasurementKind.HISTOGRAM,
+        start: bool = True,
+    ) -> TOFMeasurement:
+        """Start or stop Measurements from the TOF sensor."""
+        ...
+
+    async def get_tof_histogram(self, sensor: TOFSensor) -> TOFMeasurementResult:
+        """Get the full histogram measurement from the TOF sensor."""
+        ...
+
+    async def set_tof_configuration(
+        self,
+        sensor: TOFSensor,
+        spad_map_id: SpadMapID,
+        active_range: Optional[ActiveRange] = None,
+        kilo_iterations: Optional[int] = None,
+        report_period_ms: Optional[int] = None,
+        histogram_dump: Optional[bool] = None,
+    ) -> None:
+        """Set the configuration of the TOF sensor.
+
+        :param sensor: The TOF sensor to configure.
+        :param spad_map_id: The pre-defined SPAD map which sets the fov and focus area (14 default).
+        :active_range: The operating mode Short-range high-accuracy (default) or long range.
+        :kilo_iterations: The Measurement iterations times 1024 (4000 default).
+        :report_period_ms: The reporting period before each measurement (500 default).
+        :histogram_dump: Enables/Disables histogram measurements (True default).
+        :return: None
+        """
+        ...
+
+    async def get_tof_configuration(self, sensor: TOFSensor) -> TOFConfiguration:
+        """Get the configuration of the TOF sensor."""
+        ...
+
+    async def set_motor_driver_register(
+        self, axis: StackerAxis, reg: int, value: int
+    ) -> None:
+        """Set the register of the given motor axis driver to the given value."""
+        ...
+
+    async def get_motor_driver_register(self, axis: StackerAxis, reg: int) -> int:
+        """Gets the register value of the given motor axis driver."""
+        ...
+
+    async def set_tof_driver_register(
+        self, sensor: TOFSensor, reg: int, value: int
+    ) -> None:
+        """Set the register of the given tof sensor driver to the given value."""
+        ...
+
+    async def get_tof_driver_register(self, sensor: TOFSensor, reg: int) -> int:
+        """Gets the register value of the given tof sensor driver."""
+        ...
+
+    async def get_tof_sensor_status(self, sensor: TOFSensor) -> TOFSensorStatus:
+        """Get the status of the tof sensor."""
+        ...
+
+    async def get_motion_params(self, axis: StackerAxis) -> MoveParams:
+        """Get the motion parameters used by the given axis motor."""
+        ...
+
+    async def get_stallguard_threshold(self, axis: StackerAxis) -> StallGuardParams:
+        """Get the stallguard parameters by the given axis motor."""
+        ...
+
     async def get_limit_switch(self, axis: StackerAxis, direction: Direction) -> bool:
         """Get limit switch status.
 
@@ -48,6 +148,10 @@ class AbstractStackerDriver(Protocol):
         """
         ...
 
+    async def get_limit_switches_status(self) -> LimitSwitchStatus:
+        """Get limit switch statuses for all axes."""
+        ...
+
     async def get_platform_sensor(self, direction: Direction) -> bool:
         """Get platform sensor status.
 
@@ -66,24 +170,45 @@ class AbstractStackerDriver(Protocol):
         """
         ...
 
+    async def get_installation_detected(self) -> bool:
+        """Get whether or not installation is detected.
+
+        :return: True if installation is detected, False otherwise
+        """
+        ...
+
     async def move_in_mm(
         self, axis: StackerAxis, distance: float, params: MoveParams | None = None
-    ) -> bool:
-        """Move axis."""
+    ) -> MoveResult:
+        """Move axis by the given distance in mm."""
         ...
 
     async def move_to_limit_switch(
         self, axis: StackerAxis, direction: Direction, params: MoveParams | None = None
-    ) -> bool:
+    ) -> MoveResult:
         """Move until limit switch is triggered."""
         ...
 
-    async def home_axis(self, axis: StackerAxis, direction: Direction) -> bool:
+    async def home_axis(self, axis: StackerAxis, direction: Direction) -> MoveResult:
         """Home axis."""
         ...
 
     async def set_led(
-        self, power: float, color: LEDColor | None = None, external: bool | None = None
-    ) -> bool:
-        """Set LED color of status bar."""
+        self,
+        power: float,
+        color: Optional[LEDColor] = None,
+        external: Optional[bool] = None,
+        pattern: Optional[LEDPattern] = None,
+        duration: Optional[int] = None,
+        reps: Optional[int] = None,
+    ) -> None:
+        """Set LED Status bar color and pattern."""
+        ...
+
+    async def enter_programming_mode(self) -> None:
+        """Reboot into programming mode"""
+        ...
+
+    def reset_serial_buffers(self) -> None:
+        """Reset the input and output serial buffers."""
         ...