opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.7.0a7'
-__version_tuple__ = version_tuple = (8, 7, 0, 'a7')
+__version__ = version = '8.8.0a7'
+__version_tuple__ = version_tuple = (8, 8, 0, 'a7')
 
 __commit_id__ = commit_id = None

opentrons/cli/analyze.py

@@ -60,7 +60,7 @@ from opentrons.protocol_engine import (
     StateSummary,
 )
 from opentrons.protocol_engine.protocol_engine import code_in_error_tree
-from opentrons.protocol_engine.types import CommandAnnotation
+from opentrons.protocol_engine.types import CommandAnnotation, CommandPreconditions
 
 from opentrons_shared_data.robot.types import RobotType
 
@@ -367,6 +367,7 @@ async def _do_analyze(
             ),
             parameters=[],
             command_annotations=[],
+            command_preconditions=None,
         )
         return analysis
     return await orchestrator.run(deck_configuration=[])
@@ -465,6 +466,7 @@ async def _analyze(  # noqa: C901
         liquids=analysis.state_summary.liquids,
         commandAnnotations=analysis.command_annotations,
         liquidClasses=analysis.state_summary.liquidClasses,
+        commandPreconditions=analysis.command_preconditions,
     )
 
     _call_for_output_of_kind(
@@ -555,3 +557,4 @@ class AnalyzeResults(BaseModel):
     liquidClasses: List[LiquidClassRecordWithId]
     errors: List[ErrorOccurrence]
     commandAnnotations: List[CommandAnnotation]
+    commandPreconditions: Optional[CommandPreconditions]

opentrons/config/__init__.py

@@ -307,6 +307,13 @@ CONFIG_ELEMENTS = (
         ConfigElementType.DIR,
         "The dir where performance metrics are stored",
     ),
+    ConfigElement(
+        "live_stream_environment_file",
+        "Live Stream Configuration",
+        Path("opentrons-live-stream.env"),
+        ConfigElementType.FILE,
+        "The file storing the Opentrons Live Stream Configuration values.",
+    ),
 )
 #: The available configuration file elements to modify. All of these can be
 #: changed by editing opentrons.json, where the keys are the name elements,

opentrons/drivers/asyncio/communication/serial_connection.py

@@ -483,7 +483,10 @@ class AsyncResponseSerialConnection(SerialConnection):
         )
 
     async def send_command(
-        self, command: CommandBuilder, retries: int = 0, timeout: float | None = None
+        self,
+        command: CommandBuilder,
+        retries: int | None = None,
+        timeout: float | None = None,
     ) -> str:
         """
         Send a command and return the response.
@@ -499,7 +502,7 @@ class AsyncResponseSerialConnection(SerialConnection):
         """
         return await self.send_data(
             data=command.build(),
-            retries=retries or self._number_of_retries,
+            retries=retries if retries is not None else self._number_of_retries,
             timeout=timeout,
         )
 
@@ -515,7 +518,7 @@ class AsyncResponseSerialConnection(SerialConnection):
             )
 
     async def send_data(
-        self, data: str, retries: int = 0, timeout: float | None = None
+        self, data: str, retries: int | None = None, timeout: float | None = None
     ) -> str:
         """
         Send data and return the response.
@@ -533,7 +536,8 @@ class AsyncResponseSerialConnection(SerialConnection):
             "timeout", timeout
         ):
             return await self._send_data(
-                data=data, retries=retries or self._number_of_retries
+                data=data,
+                retries=retries if retries is not None else self._number_of_retries,
             )
 
     async def _consume_responses(
@@ -618,7 +622,6 @@ class AsyncResponseSerialConnection(SerialConnection):
 
         Raises: SerialException from an error ack to this command or an async error.
         """
-        retries = retries or self._number_of_retries
         responses: list[str] = []
 
         for retry in range(retries + 1):

opentrons/drivers/flex_stacker/driver.py

@@ -461,7 +461,12 @@ class FlexStackerDriver(AbstractFlexStackerDriver):
         command = GCODE.GET_TOF_MEASUREMENT.build_command().add_element(sensor.name)
         if resend:
             command.add_element("R")
-        resp = await self._connection.send_command(command)
+
+        # Note: We DONT want to auto resend the request if it fails, because the
+        # firmware will send the next frame id instead of the current one missed.
+        # So lets set `retries=0` so we only send the frame once and we can
+        # use the retry mechanism of the `get_tof_histogram` method instead.
+        resp = await self._connection.send_command(command, retries=0)
         return self.parse_get_tof_measurement(resp)
 
     async def get_tof_histogram(self, sensor: TOFSensor) -> TOFMeasurementResult:

opentrons/drivers/vacuum_module/__init__.py

@@ -0,0 +1,5 @@
+from .driver import VacuumModuleDriver
+from .simulator import SimulatingDriver
+from .abstract import AbstractVacuumModuleDriver
+
+__all__ = ["VacuumModuleDriver", "SimulatingDriver", "AbstractVacuumModuleDriver"]

opentrons/drivers/vacuum_module/abstract.py

@@ -0,0 +1,93 @@
+from typing import Protocol, Optional
+
+from .types import VacuumModuleInfo, LEDColor, LEDPattern
+
+
+class AbstractVacuumModuleDriver(Protocol):
+    """Protocol for the Vacuum Module driver."""
+
+    async def connect(self) -> None:
+        """Connect to vacuum module."""
+        ...
+
+    async def disconnect(self) -> None:
+        """Disconnect from vacuum module."""
+        ...
+
+    async def is_connected(self) -> bool:
+        """Check connection to vacuum module."""
+        ...
+
+    async def get_device_info(self) -> VacuumModuleInfo:
+        """Get Device Info."""
+        ...
+
+    async def set_serial_number(self, sn: str) -> None:
+        """Set Serial Number."""
+        ...
+
+    async def enable_pump(self) -> None:
+        """Enable the vacuum pump."""
+        ...
+
+    async def disable_pump(self) -> None:
+        """Disable the vacuum pump."""
+        ...
+
+    async def get_pump_motor_register(self) -> None:
+        """Get the register value of the pump motor driver."""
+        ...
+
+    async def get_pressure_sensor_register(self) -> None:
+        """Get the register value of the pressure sensor driver."""
+        ...
+
+    async def get_pressure_sensor_reading_psi(self) -> float:
+        """Get a reading from the pressure sensor."""
+        ...
+
+    async def set_vacuum_chamber_pressure(
+        self,
+        gage_pressure_mbarg: float,
+        duration: Optional[float],
+        rate: Optional[float],
+    ) -> None:
+        """Engage or release the vacuum until a desired internal pressure is reached."""
+        ...
+
+    async def get_gage_pressure_reading_mbarg(self) -> float:
+        """Read each pressure sensor and return the pressure difference."""
+        return 0.0
+
+    # TODO: change pump power to be more specific when we find out how were gonna operate that
+    async def engage_vacuum(self, pump_power: Optional[float] = None) -> None:
+        """Engage the vacuum without regard to chamber pressure."""
+        ...
+
+    async def disengage_vacuum_pump(self) -> None:
+        """Stops the vacuum pump, doesn't vent air or disable the motor."""
+        ...
+
+    async def vent(self) -> None:
+        """Release the vacuum in the module chamber."""
+        ...
+
+    async def set_led(
+        self,
+        power: float,
+        color: Optional[LEDColor] = None,
+        external: Optional[bool] = None,
+        pattern: Optional[LEDPattern] = None,
+        duration: Optional[int] = None,  # Default firmware duration is 500ms
+        reps: Optional[int] = None,  # Default firmware reps is 0
+    ) -> None:
+        """Set LED Status bar color and pattern."""
+        ...
+
+    async def enter_programming_mode(self) -> None:
+        """Reboot into programming mode"""
+        ...
+
+    async def reset_serial_buffers(self) -> None:
+        """Reset the input and output serial buffers."""
+        ...

opentrons/drivers/vacuum_module/driver.py

@@ -0,0 +1,208 @@
+import asyncio
+import re
+from typing import Optional
+
+from opentrons.drivers.asyncio.communication import AsyncResponseSerialConnection
+from .abstract import AbstractVacuumModuleDriver
+from .types import LEDColor, LEDPattern, GCODE, VacuumModuleInfo, HardwareRevision
+from .errors import VacuumModuleErrorCodes
+
+
+VM_BAUDRATE = 115200
+DEFAULT_VM_TIMEOUT = 5
+VM_ACK = "OK\n"
+VM_ERROR_KEYWORD = "err"
+VM_ASYNC_ERROR_ACK = "async"
+DEFAULT_COMMAND_RETRIES = 2
+GCODE_ROUNDING_PRECISION = 2
+
+# LED animation range values
+MIN_DURATION_MS = 25  # 25ms
+MAX_DURATION_MS = 10000  # 10s
+MAX_REPS = 10
+
+
+class VacuumModuleDriver(AbstractVacuumModuleDriver):
+    """Driver for Opentrons Vacuum Module."""
+
+    @classmethod
+    def parse_device_info(cls, response: str) -> VacuumModuleInfo:
+        """Parse vacuum module info."""
+        _RE = re.compile(
+            f"^{GCODE.GET_DEVICE_INFO} FW:(?P<fw>\\S+) HW:Opentrons-vacuum-module-(?P<hw>\\S+) SerialNo:(?P<sn>\\S+)$"
+        )
+        m = _RE.match(response)
+        if not m:
+            raise ValueError(f"Incorrect Response for device info: {response}")
+        return VacuumModuleInfo(
+            m.group("fw"), HardwareRevision(m.group("hw")), m.group("sn")
+        )
+
+    @classmethod
+    def parse_reset_reason(cls, response: str) -> int:
+        """Parse the reset reason"""
+        _RE = re.compile(rf"^{GCODE.GET_RESET_REASON} R:(?P<R>\d)$")
+        match = _RE.match(response)
+        if not match:
+            raise ValueError(f"Incorrect Response for reset reason: {response}")
+        return int(match.group("R"))
+
+    @classmethod
+    async def create(
+        cls, port: str, loop: Optional[asyncio.AbstractEventLoop]
+    ) -> "VacuumModuleDriver":
+        """Create a Vacuum Module driver."""
+        connection = await AsyncResponseSerialConnection.create(
+            port=port,
+            baud_rate=VM_BAUDRATE,
+            timeout=DEFAULT_VM_TIMEOUT,
+            number_of_retries=DEFAULT_COMMAND_RETRIES,
+            ack=VM_ACK,
+            loop=loop,
+            error_keyword=VM_ERROR_KEYWORD,
+            async_error_ack=VM_ASYNC_ERROR_ACK,
+            reset_buffer_before_write=True,
+            error_codes=VacuumModuleErrorCodes,
+        )
+        return cls(connection)
+
+    def __init__(self, connection: AsyncResponseSerialConnection) -> None:
+        """
+        Constructor
+
+        Args:
+            connection: connection to the vacuum module
+        """
+        self._connection = connection
+
+    async def connect(self) -> None:
+        """Connect to vacuum module."""
+        await self._connection.open()
+
+    async def disconnect(self) -> None:
+        """Disconnect from vacuum module."""
+        await self._connection.close()
+
+    async def is_connected(self) -> bool:
+        """Check connection to vacuum module."""
+        return await self._connection.is_open()
+
+    async def reset_serial_buffers(self) -> None:
+        """Reset the input and output serial buffers."""
+        self._connection._serial.reset_input_buffer()
+        self._connection._serial.reset_output_buffer()
+
+    async def get_device_info(self) -> VacuumModuleInfo:
+        """Get Device Info."""
+        response = await self._connection.send_command(
+            GCODE.GET_DEVICE_INFO.build_command()
+        )
+        device_info = self.parse_device_info(response)
+        reason_resp = await self._connection.send_command(
+            GCODE.GET_RESET_REASON.build_command()
+        )
+        reason = self.parse_reset_reason(reason_resp)
+        device_info.rr = reason
+        return device_info
+
+    async def enter_programming_mode(self) -> None:
+        """Reboot into programming mode"""
+        command = GCODE.ENTER_BOOTLOADER.build_command()
+        await self._connection.send_dfu_command(command)
+        await self._connection.close()
+
+    async def set_serial_number(self, sn: str) -> None:
+        """Set Serial Number."""
+        if not re.match(r"^VM[\w]{1}[\d]{2}[\d]{8}[\d]+$", sn):
+            raise ValueError(
+                f"Invalid serial number: ({sn}) expected format: VMA1020250119001"
+            )
+        resp = await self._connection.send_command(
+            GCODE.SET_SERIAL_NUMBER.build_command().add_element(sn)
+        )
+        if not re.match(rf"^{GCODE.SET_SERIAL_NUMBER}$", resp):
+            raise ValueError(f"Incorrect Response for set serial number: {resp}")
+
+    async def set_led(
+        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.
+
+        :param power: Power of the LED (0-1.0), 0 is off, 1 is full power
+        :param color: Color of the LED
+        :param external: True if external LED, False if internal LED
+        :param pattern: Animation pattern of the LED status bar
+        :param duration: Animation duration in milliseconds (25-10000), 10s max
+        :param reps: Number of times to repeat the animation (-1 - 10), -1 is forever.
+        """
+        power = max(0, min(power, 1.0))
+        command = GCODE.SET_LED.build_command().add_float(
+            "P", power, GCODE_ROUNDING_PRECISION
+        )
+        if color is not None:
+            command.add_int("C", color.value)
+        if external is not None:
+            command.add_int("K", int(external))
+        if pattern is not None:
+            command.add_int("A", pattern.value)
+        if duration is not None:
+            duration = max(MIN_DURATION_MS, min(duration, MAX_DURATION_MS))
+            command.add_int("D", duration)
+        if reps is not None:
+            command.add_int("R", max(-1, min(reps, MAX_REPS)))
+        resp = await self._connection.send_command(command)
+        if not re.match(rf"^{GCODE.SET_LED}$", resp):
+            raise ValueError(f"Incorrect Response for set led: {resp}")
+
+    async def enable_pump(self) -> None:
+        """Enables the vacuum pump, does not turn it on."""
+        ...
+
+    async def disable_pump(self) -> None:
+        """Disable the vacuum pump, doesn't just turn it off."""
+        ...
+
+    async def get_pump_motor_register(self) -> None:
+        """Get the register value of the pump motor driver."""
+        ...
+
+    async def get_pressure_sensor_register(self) -> None:
+        """Get the register value of the pressure sensor driver."""
+        ...
+
+    async def get_pressure_sensor_reading_psi(self) -> float:
+        """Get a reading from the pressure sensor."""
+        return 0.0
+
+    async def get_gage_pressure_reading_mbarg(self) -> float:
+        """Read each pressure sensor and return the pressure difference."""
+        return 0.0
+
+    async def set_vacuum_chamber_pressure(
+        self,
+        gage_pressure_mbarg: float,
+        duration: Optional[float],
+        rate: Optional[float],
+    ) -> None:
+        """Engage or release the vacuum until a desired internal pressure is reached."""
+        ...
+
+    # TODO: change pump power to be more specific when we find out how were gonna operate that
+    async def engage_vacuum(self, pump_power: Optional[float] = None) -> None:
+        """Engage the vacuum without regard to chamber pressure."""
+        ...
+
+    async def disengage_vacuum_pump(self) -> None:
+        """Stops the vacuum pump, doesn't vent air or disable the motor."""
+        ...
+
+    # turns off motor, then releases, takes a timeout for buffer between turn off and vent
+    async def vent(self) -> None:
+        """Release the vacuum in the module chamber."""
+        ...

opentrons/drivers/vacuum_module/errors.py

@@ -0,0 +1,39 @@
+"""Vacuum Module-specific errors and exceptions."""
+
+from opentrons.drivers.asyncio.communication.errors import (
+    BaseErrorCode,
+    ErrorResponse,
+    GCodeCacheFull,
+    TaskNotReady,
+    UnhandledGcode,
+)
+
+
+class EStopTriggered(ErrorResponse):
+    """Raised when the estop is triggered during a module action."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class PumpMotorError(ErrorResponse):
+    """Raised when pump motor error is received."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class StopRequested(ErrorResponse):
+    """Raised when a stop is requested during a module action."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class VacuumModuleErrorCodes(BaseErrorCode):
+    """Vacuum Module Error Codes."""
+
+    UNHANDLED_GCODE = ("ERR003", UnhandledGcode)
+    GCODE_CACHE_FULL = ("ERR004", GCodeCacheFull)
+    TASK_NOT_READY = ("ERR007", TaskNotReady)
+    STOP_REQUESTED = ("ERR504", StopRequested)

opentrons/drivers/vacuum_module/simulator.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+from .abstract import AbstractVacuumModuleDriver
+from .types import VacuumModuleInfo, HardwareRevision, LEDPattern, LEDColor
+from opentrons.util.async_helpers import ensure_yield
+
+
+class SimulatingDriver(AbstractVacuumModuleDriver):
+    def __init__(self, serial_number: str) -> None:
+        self._serial_number = serial_number
+        self.vacuum_on = False
+        self.pump_enabled = False
+        self.pressure_sensor_enabled = False
+
+    @ensure_yield
+    async def connect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        return True
+
+    async def get_device_info(self) -> VacuumModuleInfo:
+        return VacuumModuleInfo(
+            fw="vacuum-fw", hw=HardwareRevision.NFF, sn=self._serial_number
+        )
+
+    async def set_serial_number(self, sn: str) -> None:
+        self._serial_number = sn
+
+    async def enable_pump(self) -> None:
+        self.pump_enabled = True
+
+    async def disable_pump(self) -> None:
+        self.pump_enabled = False
+
+    async def get_pump_motor_register(self) -> None:
+        """Get the register value of the pump motor driver."""
+        pass
+
+    async def get_pressure_sensor_register(self) -> None:
+        """Get the register value of the pressure sensor driver."""
+        pass
+
+    async def get_pressure_sensor_reading(self) -> float:
+        """Get a reading from the pressure sensor."""
+        return 0.0
+
+    # TODO: update the pressure arg with the units when we find out which unit
+    async def set_vacuum_chamber_pressure(
+        self,
+        guage_pressure_mbar: float,
+        duration: Optional[float],
+        rate: Optional[float],
+        vent_after: bool = False,
+    ) -> None:
+        """Engage or release the vacuum until a desired internal pressure is reached."""
+        pass
+
+    async def engage_vacuum(self, pump_power: Optional[float] = None) -> None:
+        self.vacuum_on = True
+
+    async def vent(self, delay_s: float = 0.0) -> None:
+        self.vacuum_on = False
+
+    async def set_led(
+        self,
+        power: float,
+        color: Optional[LEDColor] = None,
+        external: Optional[bool] = None,
+        pattern: Optional[LEDPattern] = None,
+        duration: Optional[int] = None,  # Default firmware duration is 500ms
+        reps: Optional[int] = None,  # Default firmware reps is 0
+    ) -> None:
+        pass
+
+    async def enter_programming_mode(self) -> None:
+        pass
+
+    async def reset_serial_buffers(self) -> None:
+        pass

opentrons/drivers/vacuum_module/types.py

@@ -0,0 +1,79 @@
+from enum import Enum
+from dataclasses import dataclass
+from typing import Dict
+
+from opentrons.drivers.command_builder import CommandBuilder
+
+
+class GCODE(str, Enum):
+
+    GET_RESET_REASON = "M114"
+    GET_DEVICE_INFO = "M115"
+    SET_SERIAL_NUMBER = "M996"
+    ENTER_BOOTLOADER = "dfu"
+    SET_LED = "M200"
+
+    def build_command(self) -> CommandBuilder:
+        """Build command."""
+        return CommandBuilder().add_gcode(self)
+
+
+class HardwareRevision(Enum):
+    """Hardware Revision."""
+
+    NFF = "nff"
+
+
+@dataclass
+class VacuumModuleInfo:
+    """Vacuum module info."""
+
+    fw: str
+    hw: HardwareRevision
+    sn: str
+    rr: int = 0
+
+    def to_dict(self) -> Dict[str, str]:
+        """Build vacuum module info."""
+        return {
+            "serial": self.sn,
+            "version": self.fw,
+            "model": self.hw.value,
+            "reset_reason": str(self.rr),
+        }
+
+
+class LEDColor(Enum):
+    """Vacuum Module LED Color."""
+
+    WHITE = 0
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+    YELLOW = 4
+
+    @classmethod
+    def from_name(cls, name: str) -> "LEDColor":
+        match (name.lower()):
+            case "red":
+                return cls.RED
+            case "green":
+                return cls.GREEN
+            case "blue":
+                return cls.BLUE
+            case "yellow":
+                return cls.YELLOW
+            case _:
+                return cls.WHITE
+
+    def to_name(self) -> "str":
+        return self.name.lower()
+
+
+class LEDPattern(Enum):
+    """Vacuum Module LED Pattern."""
+
+    STATIC = 0
+    FLASH = 1
+    PULSE = 2
+    CONFIRM = 3

opentrons/execute.py

@@ -555,6 +555,7 @@ def _create_live_context_pe(
             load_fixed_trash=should_load_fixed_trash_labware_for_python_protocol(
                 api_version
             ),
+            camera_provider=None,
         )
     )
 
@@ -644,6 +645,7 @@ def _run_file_pe(
             hardware_api=hardware_api_wrapped,
         )
 
+        # todo (chb, 2025-09-30): The Camera Provider is provided in to a run by the robot server, no analog exists for execute
         orchestrator = RunOrchestrator(
             hardware_api=hardware_api_wrapped,
             protocol_engine=protocol_engine,
@@ -657,6 +659,7 @@ def _run_file_pe(
             protocol_live_runner=LiveRunner(
                 protocol_engine=protocol_engine, hardware_api=hardware_api_wrapped
             ),
+            camera_provider=None,
         )
 
         unsubscribe = protocol_runner.broker.subscribe(

opentrons/hardware_control/backends/flex_protocol.py

@@ -176,6 +176,7 @@ class FlexBackend(Protocol):
         speed: float,
         stop_condition: HWStopCondition = HWStopCondition.none,
         nodes_in_moves_only: bool = True,
+        delay: Optional[Tuple[List[Axis], float]] = None,
     ) -> None:
         """Move to a position.
 
@@ -451,6 +452,7 @@ class FlexBackend(Protocol):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         ...