opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__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.7.0a9'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a9')
 
 __commit_id__ = commit_id = None

opentrons/drivers/asyncio/communication/serial_connection.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Type, Literal, AsyncIterator
+from typing import Optional, List, Type
 
 from opentrons.drivers.command_builder import CommandBuilder
 
@@ -25,7 +25,7 @@ class SerialConnection:
         port: str,
         baud_rate: int,
         timeout: float,
-        loop: asyncio.AbstractEventLoop | None,
+        loop: Optional[asyncio.AbstractEventLoop],
         reset_buffer_before_write: bool,
     ) -> AsyncSerial:
         return await AsyncSerial.create(
@@ -43,11 +43,11 @@ class SerialConnection:
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: str | None = None,
+        name: Optional[str] = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: asyncio.AbstractEventLoop | None = None,
-        error_keyword: str | None = None,
-        alarm_keyword: str | None = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        error_keyword: Optional[str] = None,
+        alarm_keyword: Optional[str] = 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: float | None = None
+        self, command: CommandBuilder, retries: int = 0, timeout: Optional[float] = 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: float | None = None
+        self, data: str, retries: int = 0, timeout: Optional[float] = 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) -> str:
+    async def _send_data(self, data: str, retries: int = 0) -> str:
         """
         Send data and return the response.
 
@@ -351,14 +351,14 @@ class AsyncResponseSerialConnection(SerialConnection):
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: str | None = None,
+        name: Optional[str] = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: asyncio.AbstractEventLoop | None = None,
-        error_keyword: str | None = None,
-        alarm_keyword: str | None = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        error_keyword: Optional[str] = None,
+        alarm_keyword: Optional[str] = None,
         reset_buffer_before_write: bool = False,
         error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
-        async_error_ack: str | None = None,
+        async_error_ack: Optional[str] = None,
         number_of_retries: int = 0,
     ) -> AsyncResponseSerialConnection:
         """
@@ -461,29 +461,11 @@ class AsyncResponseSerialConnection(SerialConnection):
         self._alarm_keyword = alarm_keyword.lower()
         self._async_error_ack = async_error_ack.lower()
 
-    async def send_multiack_command(
+    async def send_command(
         self,
         command: CommandBuilder,
-        retries: int = 0,
+        retries: int | None = None,
         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, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send a command and return the response.
@@ -499,23 +481,12 @@ 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,
         )
 
-    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 = 0, timeout: float | None = None
+        self, data: str, retries: int | None = None, timeout: float | None = None
     ) -> str:
         """
         Send data and return the response.
@@ -533,102 +504,57 @@ class AsyncResponseSerialConnection(SerialConnection):
             "timeout", timeout
         ):
             return await self._send_data(
-                data=data, retries=retries or self._number_of_retries
-            )
-
-    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()
+                data=data,
+                retries=retries if retries is not None else self._number_of_retries,
             )
-            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]:
+    async def _send_data(self, data: str, retries: int = 0) -> str:
         """
-        Send data and return the response(s).
+        Send data and return the response.
 
         Args:
             data: The data to send.
             retries: number of times to retry in case of timeout
-            acks: The number of expected command responses
-
-        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
 
-        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.
+        Returns: The command response
 
-        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.
+        Raises: SerialException
+        """
+        data_encode = data.encode()
 
-        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.
+        for retry in range(retries + 1):
+            log.debug(f"{self._name}: Write -> {data_encode!r}")
+            await self._serial.write(data=data_encode)
 
-        Returns: The command responses
+            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)
 
-        Raises: SerialException from an error ack to this command or an async error.
-        """
-        retries = retries or self._number_of_retries
-        responses: list[str] = []
+            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
 
-        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/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/heater_shaker/abstract.py

@@ -74,8 +74,3 @@ 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,7 +27,6 @@ class GCODE(str, Enum):
     GET_LABWARE_LATCH_STATE = "M241"
     DEACTIVATE_HEATER = "M106"
     GET_RESET_REASON = "M114"
-    GET_ERROR_STATE = "M411"
 
 
 HS_BAUDRATE = 115200
@@ -203,12 +202,3 @@ 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,7 +92,3 @@ 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,7 +55,6 @@ 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"""
         ...
@@ -98,8 +97,3 @@ 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, TypeVar, Generic
+from typing import Optional, Dict, Union
 
 from opentrons.drivers import utils
 from opentrons.drivers.command_builder import CommandBuilder
@@ -36,7 +36,6 @@ 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)
@@ -74,7 +73,7 @@ class ThermocyclerDriverFactory:
     @staticmethod
     async def create(
         port: str, loop: Optional[asyncio.AbstractEventLoop]
-    ) -> ThermocyclerDriver | ThermocyclerDriverV2:
+    ) -> ThermocyclerDriver:
         """
         Create a thermocycler driver.
 
@@ -149,15 +148,10 @@ class ThermocyclerDriverFactory:
         return response.startswith(GCODE.DEVICE_INFO)
 
 
-_ConnectionKind = TypeVar(
-    "_ConnectionKind", SerialConnection, AsyncResponseSerialConnection
-)
-
-
-class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKind]):
+class ThermocyclerDriver(AbstractThermocyclerDriver):
     def __init__(
         self,
-        connection: _ConnectionKind,
+        connection: SerialKind,
     ) -> None:
         """
         Constructor
@@ -165,7 +159,7 @@ class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKin
         Args:
             connection: SerialConnection to the thermocycler
         """
-        self._connection: _ConnectionKind = connection
+        self._connection = connection
 
     async def connect(self) -> None:
         """Connect to thermocycler"""
@@ -232,7 +226,6 @@ class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKin
         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))
@@ -335,15 +328,8 @@ class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKin
             "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(_BaseThermocyclerDriver[AsyncResponseSerialConnection]):
+class ThermocyclerDriverV2(ThermocyclerDriver):
     """
     This driver is for Thermocycler model Gen2.
     """
@@ -357,38 +343,10 @@ class ThermocyclerDriverV2(_BaseThermocyclerDriver[AsyncResponseSerialConnection
         """
         super().__init__(connection)
 
-    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 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 get_device_info(self) -> Dict[str, str]:
         """Send get device info command"""
@@ -435,12 +393,3 @@ class ThermocyclerDriverV2(_BaseThermocyclerDriver[AsyncResponseSerialConnection
             .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,12 +67,10 @@ 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:
@@ -126,7 +124,3 @@ class SimulatingDriver(AbstractThermocyclerDriver):
             if angle < 0
             else ThermocyclerLidStatus.OPEN
         )
-
-    @ensure_yield
-    async def get_error_state(self) -> None:
-        return

opentrons/hardware_control/api.py

@@ -44,7 +44,6 @@ from .execution_manager import ExecutionManagerProvider
 from .pause_manager import PauseManager
 from .module_control import AttachedModulesControl
 from .types import (
-    AsynchronousModuleErrorNotification,
     Axis,
     CriticalPoint,
     DoorState,
@@ -52,7 +51,6 @@ from .types import (
     ErrorMessageNotification,
     HardwareEventHandler,
     HardwareAction,
-    HardwareEvent,
     MotionChecks,
     PauseType,
     StatusBarState,
@@ -169,18 +167,6 @@ class API(
             except Exception:
                 mod_log.exception("Errored during door state event callback")
 
-    def _send_module_notification(self, event: HardwareEvent) -> None:
-        if not isinstance(event, AsynchronousModuleErrorNotification):
-            return
-        mod_log.info(
-            f"Forwarding module event {event.event} for {event.module_model} {event.module_serial} at {event.port}"
-        )
-        for cb in self._callbacks:
-            try:
-                cb(event)
-            except Exception:
-                mod_log.exception("Errored during module asynchronous callback")
-
     def _reset_last_mount(self) -> None:
         self._last_moved_mount = None
 
@@ -261,9 +247,7 @@ class API(
             )
             await api_instance.cache_instruments()
             module_controls = await AttachedModulesControl.build(
-                api_instance,
-                board_revision=backend.board_revision,
-                event_callback=api_instance._send_module_notification,
+                api_instance, board_revision=backend.board_revision
             )
             backend.module_controls = module_controls
             checked_loop.create_task(backend.watch(loop=checked_loop))
@@ -322,9 +306,7 @@ class API(
         )
         await api_instance.cache_instruments()
         module_controls = await AttachedModulesControl.build(
-            api_instance,
-            board_revision=backend.board_revision,
-            event_callback=api_instance._send_module_notification,
+            api_instance, board_revision=backend.board_revision
         )
         backend.module_controls = module_controls
         await backend.watch()
@@ -1330,10 +1312,9 @@ class API(
             self.is_simulator
         ), "Cannot build simulating module from non-simulating hardware control API"
 
-        return await self._backend.module_controls.register_simulated_module(
-            simulated_usb_port=USBPort(
-                name="", port_number=1, port_group=PortGroup.MAIN
-            ),
+        return await self._backend.module_controls.build_module(
+            port="",
+            usb_port=USBPort(name="", port_number=1, port_group=PortGroup.MAIN),
             type=modules.ModuleType.from_model(model),
             sim_model=model.value,
         )

opentrons/hardware_control/backends/controller.py

@@ -360,19 +360,13 @@ class Controller:
         """Run a probe and return the new position dict"""
         return await self._smoothie_driver.probe_axis(axis, distance)
 
-    async def clean_up(self) -> None:  # noqa: C901
+    async def clean_up(self) -> None:
         try:
             loop = asyncio.get_event_loop()
         except RuntimeError:
             return
-        if hasattr(self, "_module_controls") and self._module_controls is not None:
-            await self._module_controls.clean_up()
         if hasattr(self, "_event_watcher"):
-            if (
-                loop.is_running()
-                and self._event_watcher
-                and not self._event_watcher.closed
-            ):
+            if loop.is_running() and self._event_watcher:
                 self._event_watcher.close()
         if hasattr(self, "gpio_chardev"):
             try:

opentrons/hardware_control/backends/flex_protocol.py

@@ -451,6 +451,7 @@ class FlexBackend(Protocol):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         ...
 

opentrons/hardware_control/backends/ot3controller.py

@@ -1398,9 +1398,6 @@ class OT3Controller(FlexBackend):
         except RuntimeError:
             return
 
-        if hasattr(self, "_module_controls") and self._module_controls is not None:
-            await self._module_controls.clean_up()
-
         if hasattr(self, "_event_watcher"):
             if (
                 loop.is_running()
@@ -1766,6 +1763,7 @@ class OT3Controller(FlexBackend):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         """
         Check if the gripper is at the expected location.
@@ -1808,6 +1806,7 @@ class OT3Controller(FlexBackend):
         if (
             current_gripper_position - expected_gripper_position_min
             < -max_allowed_grip_error
+            and not disable_geometry_grip_check
         ):
             raise FailedGripperPickupError(
                 message="Failed to grip: jaws closed too far",
@@ -1821,6 +1820,7 @@ class OT3Controller(FlexBackend):
         if (
             current_gripper_position - expected_gripper_position_max
             > max_allowed_grip_error
+            and not disable_geometry_grip_check
         ):
             raise FailedGripperPickupError(
                 message="Failed to grip: jaws could not close far enough",

opentrons/hardware_control/backends/ot3simulator.py

@@ -728,8 +728,7 @@ class OT3Simulator(FlexBackend):
     @ensure_yield
     async def clean_up(self) -> None:
         """Clean up."""
-        if hasattr(self, "_module_controls") and self._module_controls is not None:
-            await self._module_controls.clean_up()
+        pass
 
     @staticmethod
     def _get_home_position() -> Dict[Axis, float]:
@@ -849,6 +848,7 @@ class OT3Simulator(FlexBackend):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         # This is a (pretty bad) simulation of the gripper actually gripping something,
         # but it should work.