opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__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.0a9'
-__version_tuple__ = version_tuple = (8, 7, 0, 'a9')
+__version__ = version = '8.8.0a8'
+__version_tuple__ = version_tuple = (8, 8, 0, 'a8')
 
 __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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, List, Type
+from typing import Type, Literal, AsyncIterator
 
 from opentrons.drivers.command_builder import CommandBuilder
 
@@ -25,7 +25,7 @@ class SerialConnection:
         port: str,
         baud_rate: int,
         timeout: float,
-        loop: Optional[asyncio.AbstractEventLoop],
+        loop: asyncio.AbstractEventLoop | None,
         reset_buffer_before_write: bool,
     ) -> AsyncSerial:
         return await AsyncSerial.create(
@@ -43,11 +43,11 @@ class SerialConnection:
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: Optional[str] = None,
+        name: str | None = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-        error_keyword: Optional[str] = None,
-        alarm_keyword: Optional[str] = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        error_keyword: str | None = None,
+        alarm_keyword: str | None = None,
         reset_buffer_before_write: bool = False,
         error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
     ) -> "SerialConnection":
@@ -133,7 +133,7 @@ class SerialConnection:
         self._error_codes = error_codes
 
     async def send_command(
-        self, command: CommandBuilder, retries: int = 0, timeout: Optional[float] = None
+        self, command: CommandBuilder, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send a command and return the response.
@@ -165,7 +165,7 @@ class SerialConnection:
             await self._serial.write(data=encoded_command)
 
     async def send_data(
-        self, data: str, retries: int = 0, timeout: Optional[float] = None
+        self, data: str, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send data and return the response.
@@ -184,7 +184,7 @@ class SerialConnection:
         ):
             return await self._send_data(data=data, retries=retries)
 
-    async def _send_data(self, data: str, retries: int = 0) -> str:
+    async def _send_data(self, data: str, retries: int) -> str:
         """
         Send data and return the response.
 
@@ -351,14 +351,14 @@ class AsyncResponseSerialConnection(SerialConnection):
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: Optional[str] = None,
+        name: str | None = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-        error_keyword: Optional[str] = None,
-        alarm_keyword: Optional[str] = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        error_keyword: str | None = None,
+        alarm_keyword: str | None = None,
         reset_buffer_before_write: bool = False,
         error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
-        async_error_ack: Optional[str] = None,
+        async_error_ack: str | None = None,
         number_of_retries: int = 0,
     ) -> AsyncResponseSerialConnection:
         """
@@ -461,6 +461,27 @@ class AsyncResponseSerialConnection(SerialConnection):
         self._alarm_keyword = alarm_keyword.lower()
         self._async_error_ack = async_error_ack.lower()
 
+    async def send_multiack_command(
+        self,
+        command: CommandBuilder,
+        retries: int = 0,
+        timeout: float | None = None,
+        acks: int = 1,
+    ) -> list[str]:
+        """Send a command and return the responses.
+
+        Some commands result in multiple responses; collate them and return them all.
+
+        Args:
+            command: A command builder.
+            retries: number of times to retry in case of timeout
+            timeout: optional override of default timeout in seconds
+            acks: the number of acks to expect
+        """
+        return await self.send_data_multiack(
+            data=command.build(), retries=retries, timeout=timeout, acks=acks
+        )
+
     async def send_command(
         self,
         command: CommandBuilder,
@@ -485,6 +506,17 @@ class AsyncResponseSerialConnection(SerialConnection):
             timeout=timeout,
         )
 
+    async def send_data_multiack(
+        self, data: str, retries: int = 0, timeout: float | None = None, acks: int = 1
+    ) -> list[str]:
+        """Send data and return all responses."""
+        async with super().send_data_lock, self._serial.timeout_override(
+            "timeout", timeout
+        ):
+            return await self._send_data_multiack(
+                data=data, retries=retries or self._number_of_retries, acks=acks
+            )
+
     async def send_data(
         self, data: str, retries: int | None = None, timeout: float | None = None
     ) -> str:
@@ -508,53 +540,98 @@ class AsyncResponseSerialConnection(SerialConnection):
                 retries=retries if retries is not None else self._number_of_retries,
             )
 
-    async def _send_data(self, data: str, retries: int = 0) -> str:
+    async def _consume_responses(
+        self, acks: int
+    ) -> AsyncIterator[tuple[Literal["response", "error", "empty-unknown"], bytes]]:
+        while acks > 0:
+            data = await self._serial.read_until(match=self._ack)
+            log.debug(f"{self._name}: Read <- {data!r}")
+            if self._async_error_ack.encode() in data:
+                yield "error", data
+            elif self._ack in data:
+                yield "response", data
+                acks -= 1
+            else:
+                # A read timeout, end
+                yield "empty-unknown", data
+
+    async def _send_one_retry(self, data: str, acks: int) -> list[str]:
+        data_encode = data.encode("utf-8")
+        log.debug(f"{self._name}: Write -> {data_encode!r}")
+        await self._serial.write(data=data_encode)
+
+        command_acks: list[bytes] = []
+        async_errors: list[bytes] = []
+        # consume responses before raising so we don't raise and orphan
+        # a response in the buffer
+        async for response_type, response in self._consume_responses(acks):
+            if response_type == "error":
+                async_errors.append(response)
+            elif response_type == "response":
+                command_acks.append(response)
+            else:
+                break
+
+        for async_error in async_errors:
+            # Remove ack from response
+            ackless_response = async_error.replace(self._ack, b"")
+            str_response = self.process_raw_response(
+                command=data, response=ackless_response.decode()
+            )
+            self.raise_on_error(response=str_response, request=data)
+
+        ackless_responses: list[str] = []
+        for command_ack in command_acks:
+            # Remove ack from response
+            ackless_response = command_ack.replace(self._ack, b"")
+            str_response = self.process_raw_response(
+                command=data, response=ackless_response.decode()
+            )
+            self.raise_on_error(response=str_response, request=data)
+            ackless_responses.append(str_response)
+        return ackless_responses
+
+    async def _send_data_multiack(
+        self, data: str, retries: int, acks: int
+    ) -> list[str]:
         """
-        Send data and return the response.
+        Send data and return the response(s).
 
         Args:
             data: The data to send.
             retries: number of times to retry in case of timeout
+            acks: The number of expected command responses
 
-        Returns: The command response
+        This function retries (resends the command) up to (retries) times, and waits
+        for (acks) responses. It also listens for async errors. These are an older
+        mechanism where at the moment an error occurs, some modules will send a message
+        like async error ERR:202:whatever
 
-        Raises: SerialException
-        """
-        data_encode = data.encode()
+        This function will detect async error messages if they were sent before it
+        sent the command or if they are sent before the final ack for the command is
+        sent. It will not catch async errors otherwise.
 
-        for retry in range(retries + 1):
-            log.debug(f"{self._name}: Write -> {data_encode!r}")
-            await self._serial.write(data=data_encode)
+        This function will always try and consume all the acknowledgements specified for
+        its command if it sends the command, even if an async error happens in between.
 
-            response: List[bytes] = []
-            response.append(await self._serial.read_until(match=self._ack))
-            log.debug(f"{self._name}: Read <- {response[-1]!r}")
-
-            while self._async_error_ack.encode() in response[-1].lower():
-                # check for multiple a priori async errors
-                response.append(await self._serial.read_until(match=self._ack))
-                log.debug(f"{self._name}: Read <- {response[-1]!r}")
-
-            for r in response:
-                if self._async_error_ack.encode() in r:
-                    # Remove ack from response
-                    ackless_response = r.replace(self._ack, b"")
-                    str_response = self.process_raw_response(
-                        command=data, response=ackless_response.decode()
-                    )
-                    self.raise_on_error(response=str_response, request=data)
+        This should all work together to make sure that there aren't any leftover acks
+        after the function ends, which could lead to the read/write mechanics getting out
+        of sync.
 
-            if self._ack in response[-1]:
-                # Remove ack from response
-                ackless_response = response[-1].replace(self._ack, b"")
-                str_response = self.process_raw_response(
-                    command=data, response=ackless_response.decode()
-                )
-                self.raise_on_error(response=str_response, request=data)
-                return str_response
+        Returns: The command responses
 
-            log.info(f"{self._name}: retry number {retry}/{retries}")
+        Raises: SerialException from an error ack to this command or an async error.
+        """
+        responses: list[str] = []
 
+        for retry in range(retries + 1):
+            responses = await self._send_one_retry(data, acks)
+            if responses:
+                return responses
+            log.info(f"{self._name}: retry number {retry}/{retries}")
             await self.on_retry()
 
         raise NoResponse(port=self._port, command=data)
+
+    async def _send_data(self, data: str, retries: int) -> str:
+        return (await self._send_data_multiack(data, retries, 1))[0]

opentrons/drivers/heater_shaker/abstract.py

@@ -74,3 +74,8 @@ class AbstractHeaterShakerDriver(ABC):
     async def enter_programming_mode(self) -> None:
         """Reboot into programming mode"""
         ...
+
+    @abstractmethod
+    async def get_error_state(self) -> None:
+        """Raise if the module is in an error state."""
+        ...

opentrons/drivers/heater_shaker/driver.py

@@ -27,6 +27,7 @@ class GCODE(str, Enum):
     GET_LABWARE_LATCH_STATE = "M241"
     DEACTIVATE_HEATER = "M106"
     GET_RESET_REASON = "M114"
+    GET_ERROR_STATE = "M411"
 
 
 HS_BAUDRATE = 115200
@@ -202,3 +203,12 @@ class HeaterShakerDriver(AbstractHeaterShakerDriver):
             gcode=GCODE.DEACTIVATE_HEATER
         )
         await self._connection.send_command(command=c, retries=DEFAULT_COMMAND_RETRIES)
+
+    async def get_error_state(self) -> None:
+        """Raise if the module is in an error state."""
+        await self._connection.send_multiack_command(
+            command=CommandBuilder(terminator=HS_COMMAND_TERMINATOR).add_gcode(
+                gcode=GCODE.GET_ERROR_STATE
+            ),
+            acks=2,
+        )

opentrons/drivers/heater_shaker/simulator.py

@@ -92,3 +92,7 @@ class SimulatingDriver(AbstractHeaterShakerDriver):
     @ensure_yield
     async def enter_programming_mode(self) -> None:
         pass
+
+    @ensure_yield
+    async def get_error_state(self) -> None:
+        return

opentrons/drivers/thermocycler/abstract.py

@@ -55,6 +55,7 @@ class AbstractThermocyclerDriver(ABC):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         ...
@@ -97,3 +98,8 @@ class AbstractThermocyclerDriver(ABC):
     async def jog_lid(self, angle: float) -> None:
         """Send the Jog Lid command."""
         ...
+
+    @abstractmethod
+    async def get_error_state(self) -> None:
+        """Raise if the thermocycler is in an error state."""
+        ...

opentrons/drivers/thermocycler/driver.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from enum import Enum
-from typing import Optional, Dict, Union
+from typing import Optional, Dict, Union, TypeVar, Generic
 
 from opentrons.drivers import utils
 from opentrons.drivers.command_builder import CommandBuilder
@@ -36,6 +36,7 @@ class GCODE(str, Enum):
     DEVICE_INFO = "M115"
     GET_RESET_REASON = "M114"
     ENTER_PROGRAMMING = "dfu"
+    GET_ERROR_STATE = "M411"
 
 
 LID_TARGET_DEFAULT = 105  # Degree celsius (floats)
@@ -73,7 +74,7 @@ class ThermocyclerDriverFactory:
     @staticmethod
     async def create(
         port: str, loop: Optional[asyncio.AbstractEventLoop]
-    ) -> ThermocyclerDriver:
+    ) -> ThermocyclerDriver | ThermocyclerDriverV2:
         """
         Create a thermocycler driver.
 
@@ -148,10 +149,15 @@ class ThermocyclerDriverFactory:
         return response.startswith(GCODE.DEVICE_INFO)
 
 
-class ThermocyclerDriver(AbstractThermocyclerDriver):
+_ConnectionKind = TypeVar(
+    "_ConnectionKind", SerialConnection, AsyncResponseSerialConnection
+)
+
+
+class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKind]):
     def __init__(
         self,
-        connection: SerialKind,
+        connection: _ConnectionKind,
     ) -> None:
         """
         Constructor
@@ -159,7 +165,7 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
         Args:
             connection: SerialConnection to the thermocycler
         """
-        self._connection = connection
+        self._connection: _ConnectionKind = connection
 
     async def connect(self) -> None:
         """Connect to thermocycler"""
@@ -226,6 +232,7 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
@@ -328,8 +335,15 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
             "Gen1 Thermocyclers do not support the Jog Lid command."
         )
 
+    async def get_error_state(self) -> None:
+        """For the gen1, do nothing."""
+        pass
+
+
+ThermocyclerDriver = _BaseThermocyclerDriver[SerialConnection]
 
-class ThermocyclerDriverV2(ThermocyclerDriver):
+
+class ThermocyclerDriverV2(_BaseThermocyclerDriver[AsyncResponseSerialConnection]):
     """
     This driver is for Thermocycler model Gen2.
     """
@@ -343,10 +357,38 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
         """
         super().__init__(connection)
 
-    async def set_ramp_rate(self, ramp_rate: float) -> None:
-        """Send a set ramp rate command"""
-        # This command is fully unsupported on TC Gen2
-        return None
+    async def set_plate_temperature(
+        self,
+        temp: float,
+        hold_time: Optional[float] = None,
+        volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
+    ) -> None:
+        """Send set plate temperature command"""
+        temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
+
+        c = (
+            CommandBuilder(terminator=TC_COMMAND_TERMINATOR)
+            .add_gcode(gcode=GCODE.SET_PLATE_TEMP)
+            .add_float(
+                prefix="S", value=temp, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        )
+        if hold_time is not None:
+            c = c.add_float(
+                prefix="H", value=hold_time, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        if volume is not None:
+            c = c.add_float(
+                prefix="V", value=volume, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        if ramp_rate is not None:
+            c = c.add_float(
+                prefix="R", value=ramp_rate, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        await self._connection.send_command(command=c, retries=DEFAULT_COMMAND_RETRIES)
 
     async def get_device_info(self) -> Dict[str, str]:
         """Send get device info command"""
@@ -393,3 +435,12 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
             .add_element("O")
         )
         await self._connection.send_command(command=c, retries=1)
+
+    async def get_error_state(self) -> None:
+        """Raise an error if the thermocycler is stuck in an error state."""
+        await self._connection.send_multiack_command(
+            command=CommandBuilder(terminator=TC_COMMAND_TERMINATOR).add_gcode(
+                gcode=GCODE.GET_ERROR_STATE
+            ),
+            acks=2,
+        )

opentrons/drivers/thermocycler/simulator.py

@@ -67,10 +67,12 @@ class SimulatingDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         self._plate_temperature.target = temp
         self._plate_temperature.current = temp
         self._plate_temperature.hold = 0
+        self._ramp_rate = ramp_rate
 
     @ensure_yield
     async def get_plate_temperature(self) -> PlateTemperature:
@@ -124,3 +126,7 @@ class SimulatingDriver(AbstractThermocyclerDriver):
             if angle < 0
             else ThermocyclerLidStatus.OPEN
         )
+
+    @ensure_yield
+    async def get_error_state(self) -> None:
+        return

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."""
+        ...