opentrons 8.6.0a1__py3-none-any.whl

opentrons/hardware_control/dev_types.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+# this file defines types that require dev dependencies
+# and are only relevant for static typechecking. this file should only
+# be imported if typing.TYPE_CHECKING is True
+from typing import Optional, Dict, List, Union
+
+from typing_extensions import TypedDict, Literal
+
+from opentrons.hardware_control.instruments.ot3.instrument_calibration import (
+    GripperCalibrationOffset,
+)
+from opentrons_shared_data.pipette.types import (
+    PipetteModel,
+    PipetteName,
+    ChannelCount,
+)
+from opentrons_shared_data.pipette.types import PipetteTipType
+from opentrons_shared_data.pipette.pipette_definition import (
+    PipetteConfigurations,
+    SupportedTipsDefinition,
+    PipetteBoundingBoxOffsetDefinition,
+    AvailableSensorDefinition,
+)
+from opentrons_shared_data.gripper import (
+    GripperModel,
+    GripperDefinition,
+)
+
+from opentrons.drivers.types import MoveSplit
+from opentrons.types import Mount
+from opentrons.hardware_control.types import GripperJawState
+from opentrons.hardware_control.nozzle_manager import NozzleMap
+
+
+class InstrumentSpec(TypedDict):
+    id: Optional[str]
+
+
+class PipetteSpec(InstrumentSpec):
+    model: Union[PipetteModel, None]
+
+
+class GripperSpec(InstrumentSpec):
+    model: Union[GripperModel, None]
+
+
+class AttachedPipette(TypedDict):
+    config: Optional[PipetteConfigurations]
+    id: Optional[str]
+
+
+class AttachedGripper(TypedDict):
+    config: Optional[GripperDefinition]
+    id: Optional[str]
+
+
+AttachedInstruments = Dict[Mount, AttachedPipette]
+
+OT3AttachedInstruments = Union[AttachedPipette, AttachedGripper]
+
+EIGHT_CHANNELS = Literal[8]
+ONE_CHANNEL = Literal[1]
+
+
+class InstrumentDict(TypedDict):
+    display_name: str
+
+
+class PipetteDict(InstrumentDict):
+    name: PipetteName
+    model: PipetteModel
+    back_compat_names: List[PipetteName]
+    pipette_id: str
+    min_volume: float
+    max_volume: float
+    channels: ChannelCount
+    aspirate_flow_rate: float
+    dispense_flow_rate: float
+    blow_out_flow_rate: float
+    aspirate_speed: float
+    dispense_speed: float
+    blow_out_speed: float
+    current_volume: float
+    tip_length: float
+    working_volume: float
+    tip_overlap: Dict[str, float]
+    versioned_tip_overlap: Dict[str, Dict[str, float]]
+    available_volume: float
+    return_tip_height: float
+    default_aspirate_flow_rates: Dict[str, float]
+    default_dispense_flow_rates: Dict[str, float]
+    default_blow_out_flow_rates: Dict[str, float]
+    default_aspirate_speeds: Dict[str, float]
+    default_dispense_speeds: Dict[str, float]
+    default_blow_out_speeds: Dict[str, float]
+    ready_to_aspirate: bool
+    has_tip: bool
+    default_push_out_volume: Optional[float]
+    supported_tips: Dict[PipetteTipType, SupportedTipsDefinition]
+    pipette_bounding_box_offsets: PipetteBoundingBoxOffsetDefinition
+    current_nozzle_map: NozzleMap
+    lld_settings: Optional[Dict[str, Dict[str, float]]]
+    plunger_positions: Dict[str, float]
+    shaft_ul_per_mm: float
+    available_sensors: AvailableSensorDefinition
+
+
+class PipetteStateDict(TypedDict):
+    tip_detected: bool
+
+
+class GripperDict(InstrumentDict):
+    model: GripperModel
+    gripper_id: str
+    state: GripperJawState  # Can we call this jaw_state?
+    calibration_offset: GripperCalibrationOffset
+
+
+class InstrumentHardwareConfigs(TypedDict):
+    steps_per_mm: float
+    home_pos: float
+    max_travel: float
+    idle_current: float
+    splits: Optional[MoveSplit]

opentrons/hardware_control/emulation/abstract_emulator.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class AbstractEmulator(ABC):
+    """Interface of gcode line processing hardware emulator."""
+
+    @abstractmethod
+    def handle(self, line: str) -> Optional[str]:
+        """Handle a command and return a response."""
+        ...
+
+    @staticmethod
+    def get_terminator() -> bytes:
+        """Get the command terminator for messages coming from PI."""
+        return b"\r\n\r\n"
+
+    @staticmethod
+    def get_ack() -> bytes:
+        """Get the command ack send to the PI."""
+        return b"ok\r\nok\r\n"

opentrons/hardware_control/emulation/app.py

@@ -0,0 +1,56 @@
+import asyncio
+import logging
+
+from opentrons.hardware_control.emulation.module_server import ModuleStatusServer
+from opentrons.hardware_control.emulation.proxy import Proxy
+from opentrons.hardware_control.emulation.settings import Settings
+from opentrons.hardware_control.emulation.types import ModuleType
+
+logger = logging.getLogger(__name__)
+
+
+class Application:
+    """The emulator application."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Constructor.
+
+        Args:
+            settings: Application settings.
+        """
+        self._settings = settings
+        self._status_server = ModuleStatusServer(settings.module_server)
+        self._magdeck = Proxy(
+            ModuleType.Magnetic, self._status_server, self._settings.magdeck_proxy
+        )
+        self._temperature = Proxy(
+            ModuleType.Temperature,
+            self._status_server,
+            self._settings.temperature_proxy,
+        )
+        self._thermocycler = Proxy(
+            ModuleType.Thermocycler,
+            self._status_server,
+            self._settings.thermocycler_proxy,
+        )
+        self._heatershaker = Proxy(
+            ModuleType.Heatershaker,
+            self._status_server,
+            self._settings.heatershaker_proxy,
+        )
+
+    async def run(self) -> None:
+        """Run the application."""
+        await asyncio.gather(
+            self._status_server.run(),
+            self._magdeck.run(),
+            self._temperature.run(),
+            self._thermocycler.run(),
+            self._heatershaker.run(),
+        )
+
+
+if __name__ == "__main__":
+    logging.basicConfig(format="%(asctime)s:%(message)s", level=logging.DEBUG)
+    s = Settings()
+    asyncio.run(Application(settings=s).run())

opentrons/hardware_control/emulation/connection_handler.py

@@ -0,0 +1,38 @@
+"""The handler of a driver client connection."""
+
+import asyncio
+import logging
+
+from opentrons.hardware_control.emulation.abstract_emulator import AbstractEmulator
+
+logger = logging.getLogger(__name__)
+
+
+class ConnectionHandler:
+    """Responsible for reading data and routing it to an emulator."""
+
+    def __init__(self, emulator: AbstractEmulator):
+        """Construct with an emulator."""
+        self._emulator = emulator
+
+    async def __call__(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """New connection callback."""
+        emulator_name = self._emulator.__class__.__name__
+        logger.debug("%s Connected.", emulator_name)
+        while True:
+            line = await reader.readuntil(self._emulator.get_terminator())
+            logger.debug("%s Received: %s", emulator_name, line)
+            try:
+                response = self._emulator.handle(line.decode().strip())
+                if response:
+                    response = f"{response}\r\n"
+                    logger.debug("%s Sending: %s", emulator_name, response)
+                    writer.write(response.encode())
+            except Exception as e:
+                logger.exception("%s exception", emulator_name)
+                writer.write(f"Error: {str(e)}\r\n".encode())
+
+            writer.write(self._emulator.get_ack())
+            await writer.drain()

opentrons/hardware_control/emulation/heater_shaker.py

@@ -0,0 +1,150 @@
+"""An emulation of the opentrons heater shaker module.
+
+The purpose is to provide a fake backend that responds to GCODE commands.
+"""
+import logging
+from time import sleep
+from typing import (
+    Optional,
+)
+
+from opentrons.drivers.heater_shaker.driver import (
+    GCODE,
+    HS_ACK,
+)
+from opentrons.hardware_control.emulation.parser import Parser, Command
+from opentrons.hardware_control.emulation.settings import HeaterShakerSettings
+from . import util
+
+from .abstract_emulator import AbstractEmulator
+from .simulations import (
+    Temperature,
+    RPM,
+)
+from .util import TEMPERATURE_ROOM
+from ...drivers.types import HeaterShakerLabwareLatchStatus
+
+logger = logging.getLogger(__name__)
+
+
+class HeaterShakerEmulator(AbstractEmulator):
+    """Heater Shaker emulator"""
+
+    _temperature: Temperature
+    _rpm: RPM
+    _latch_status: HeaterShakerLabwareLatchStatus
+
+    def __init__(self, parser: Parser, settings: HeaterShakerSettings) -> None:
+        self._parser = parser
+        self._settings = settings
+        self._gcode_to_function_mapping = {
+            GCODE.SET_RPM.value: self._set_rpm,
+            GCODE.GET_RPM.value: self._get_rpm,
+            GCODE.SET_TEMPERATURE.value: self._set_temp,
+            GCODE.GET_TEMPERATURE.value: self._get_temp,
+            GCODE.HOME.value: self._home,
+            GCODE.ENTER_BOOTLOADER.value: self._enter_bootloader,
+            GCODE.GET_VERSION.value: self._get_version,
+            GCODE.GET_RESET_REASON.value: self._get_reset_reason,
+            GCODE.OPEN_LABWARE_LATCH.value: self._open_labware_latch,
+            GCODE.CLOSE_LABWARE_LATCH.value: self._close_labware_latch,
+            GCODE.GET_LABWARE_LATCH_STATE.value: self._get_labware_latch_state,
+            GCODE.DEACTIVATE_HEATER.value: self._deactivate_heater,
+        }
+        self.reset()
+
+    def handle(self, line: str) -> Optional[str]:
+        """Handle a line"""
+        results = (self._handle(c) for c in self._parser.parse(line))
+        joined = " ".join(r for r in results if r)
+        return None if not joined else joined
+
+    def reset(self) -> None:
+
+        self._temperature = Temperature(
+            per_tick=self._settings.temperature.degrees_per_tick,
+            current=self._settings.temperature.starting,
+        )
+        self._rpm = RPM(
+            per_tick=self._settings.rpm.rpm_per_tick,
+            current=self._settings.rpm.starting,
+        )
+        self._rpm.set_target(0.0)
+        self._latch_status = HeaterShakerLabwareLatchStatus.IDLE_OPEN
+
+    def _handle(self, command: Command) -> Optional[str]:
+        """
+        Handle a command.
+
+        TODO: AL 20210218 create dispatch map and remove 'noqa(C901)'
+        """
+        logger.info(f"Got command {command}")
+        func_to_run = self._gcode_to_function_mapping.get(command.gcode)
+        res = None if func_to_run is None else func_to_run(command)
+        return None if not isinstance(res, str) else f"{res} {HS_ACK}"
+
+    def _set_rpm(self, command: Command) -> str:
+        value = command.params["S"]
+        assert isinstance(value, float), f"invalid value '{value}'"
+        self._rpm.set_target(value)
+        return "M3"
+
+    def _get_rpm(self, command: Command) -> str:
+        res = (
+            f"M123 C:{self._rpm.current} "
+            f"T:{self._rpm.target if self._rpm.target is not None else 0}"
+        )
+        self._rpm.tick()
+        return res
+
+    def _set_temp(self, command: Command) -> str:
+        value = command.params["S"]
+        assert isinstance(value, float), f"invalid value '{value}'"
+        self._temperature.set_target(value)
+        return "M104"
+
+    def _get_temp(self, command: Command) -> str:
+        res = (
+            f"M105 C:{self._temperature.current} "
+            f"T:{util.OptionalValue(self._temperature.target)}"
+        )
+        self._temperature.tick()
+        return res
+
+    def _home(self, command: Command) -> str:
+        sleep(self._settings.home_delay_time)
+        self._rpm.deactivate(0.0)
+        self._rpm.set_target(0.0)
+        return "G28"
+
+    def _enter_bootloader(self, command: Command) -> None:
+        pass
+
+    def _get_version(self, command: Command) -> str:
+        return (
+            f"FW:{self._settings.version} "
+            f"HW:{self._settings.model} "
+            f"SerialNo:{self._settings.serial_number}"
+        )
+
+    def _get_reset_reason(self, command: Command) -> str:
+        return "M114 Last Reset Reason: 01"
+
+    def _open_labware_latch(self, command: Command) -> str:
+        self._latch_status = HeaterShakerLabwareLatchStatus.IDLE_OPEN
+        return "M242"
+
+    def _close_labware_latch(self, command: Command) -> str:
+        self._latch_status = HeaterShakerLabwareLatchStatus.IDLE_CLOSED
+        return "M243"
+
+    def _get_labware_latch_state(self, command: Command) -> str:
+        return f"M241 STATUS:{self._latch_status.value.upper()}"
+
+    def _deactivate_heater(self, command: Command) -> str:
+        self._temperature.deactivate(TEMPERATURE_ROOM)
+        return "M106"
+
+    @staticmethod
+    def get_terminator() -> bytes:
+        return b"\n"

opentrons/hardware_control/emulation/magdeck.py

@@ -0,0 +1,60 @@
+"""An emulation of the opentrons magnetic module.
+
+The purpose is to provide a fake backend that responds to GCODE commands.
+"""
+
+import logging
+from typing import Optional
+from opentrons.drivers.mag_deck.driver import GCODE
+from opentrons.hardware_control.emulation.parser import Parser, Command
+from .abstract_emulator import AbstractEmulator
+from .settings import MagDeckSettings
+
+logger = logging.getLogger(__name__)
+
+
+class MagDeckEmulator(AbstractEmulator):
+    """Magdeck emulator"""
+
+    height: float = 0
+    position: float = 0
+
+    def __init__(self, parser: Parser, settings: MagDeckSettings) -> None:
+        self._settings = settings
+        self._parser = parser
+        self.reset()
+
+    def handle(self, line: str) -> Optional[str]:
+        """Handle a line"""
+        results = (self._handle(c) for c in self._parser.parse(line))
+        joined = " ".join(r for r in results if r)
+        return None if not joined else joined
+
+    def reset(self) -> None:
+        self.height: float = 0
+        self.position: float = 0
+
+    def _handle(self, command: Command) -> Optional[str]:
+        """Handle a command."""
+        logger.info(f"Got command {command}")
+        if command.gcode == GCODE.HOME:
+            self.height = 0
+        elif command.gcode == GCODE.MOVE:
+            position = command.params["Z"]
+            assert isinstance(position, float), f"invalid position '{position}'"
+            self.position = position
+        elif command.gcode == GCODE.PROBE_PLATE:
+            self.height = 45
+        elif command.gcode == GCODE.GET_PLATE_HEIGHT:
+            return f"height:{self.height}"
+        elif command.gcode == GCODE.GET_CURRENT_POSITION:
+            return f"Z:{self.position}"
+        elif command.gcode == GCODE.DEVICE_INFO:
+            return (
+                f"serial:{self._settings.serial_number} "
+                f"model:{self._settings.model} "
+                f"version:{self._settings.version}"
+            )
+        elif command.gcode == GCODE.PROGRAMMING_MODE:
+            pass
+        return None

opentrons/hardware_control/emulation/module_server/__init__.py

@@ -0,0 +1,8 @@
+"""Package for the module status server."""
+from .server import ModuleStatusServer
+from .client import ModuleStatusClient
+
+__all__ = [
+    "ModuleStatusServer",
+    "ModuleStatusClient",
+]

opentrons/hardware_control/emulation/module_server/client.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import asyncio
+from asyncio import IncompleteReadError, LimitOverrunError
+from typing import Optional
+
+from opentrons.hardware_control.emulation.module_server.models import Message
+from opentrons.hardware_control.emulation.module_server.server import MessageDelimiter
+
+
+class ModuleServerClientError(Exception):
+    pass
+
+
+class ModuleServerDisconnected(ModuleServerClientError):
+    pass
+
+
+class ModuleStatusClient:
+    """A module server client."""
+
+    def __init__(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Constructor."""
+        self._reader = reader
+        self._writer = writer
+
+    @classmethod
+    async def connect(
+        cls,
+        host: str,
+        port: int,
+        retries: int = 3,
+        interval_seconds: float = 0.1,
+    ) -> ModuleStatusClient:
+        """Connect to the module server.
+
+        Args:
+            host: module server host.
+            port: module server port.
+            retries: number of retries
+            interval_seconds: time between retries.
+
+        Returns:
+            None
+        Raises:
+            IOError on retry expiry.
+        """
+        r: Optional[asyncio.StreamReader] = None
+        w: Optional[asyncio.StreamWriter] = None
+        for i in range(retries):
+            try:
+                r, w = await asyncio.open_connection(host=host, port=port)
+                break
+            except OSError:
+                await asyncio.sleep(interval_seconds)
+
+        if r is not None and w is not None:
+            return ModuleStatusClient(reader=r, writer=w)
+        else:
+            raise IOError(
+                f"Failed to connect to module_server at after {retries} retries."
+            )
+
+    async def read(self) -> Message:
+        """Read a message from the module server."""
+        try:
+            b = await self._reader.readuntil(MessageDelimiter)
+            m: Message = Message.model_validate_json(b)
+            return m
+        except LimitOverrunError as e:
+            raise ModuleServerClientError(str(e))
+        except IncompleteReadError:
+            raise ModuleServerDisconnected()
+
+    def close(self) -> None:
+        """Close the client."""
+        self._writer.close()

opentrons/hardware_control/emulation/module_server/helpers.py

@@ -0,0 +1,130 @@
+"""Utililty methods and classes for interacting with the Module Status Server."""
+
+import asyncio
+from typing import Sequence, Set, Callable, List, Awaitable
+
+from opentrons.drivers.rpi_drivers.types import USBPort
+from opentrons.hardware_control.emulation.module_server.client import (
+    ModuleStatusClient,
+    ModuleServerClientError,
+    ModuleServerDisconnected,
+)
+from opentrons.hardware_control.emulation.module_server.models import Message
+from opentrons.hardware_control.emulation.module_server.server import log
+from opentrons.hardware_control.emulation.settings import Settings
+from opentrons.hardware_control.emulation.types import ModuleType
+from opentrons.hardware_control.modules import ModuleAtPort
+
+NotifyMethod = Callable[[List[ModuleAtPort], List[ModuleAtPort]], Awaitable[None]]
+"""Signature of method to be notified of new and removed modules."""
+
+
+async def listen_module_connection(callback: NotifyMethod) -> None:
+    """Listen for module emulator connections."""
+    settings = Settings()
+    try:
+        client = await ModuleStatusClient.connect(
+            host=settings.module_server.host,
+            port=settings.module_server.port,
+            interval_seconds=1.0,
+        )
+        listener = ModuleListener(client=client, notify_method=callback)
+        await listener.run()
+    except IOError:
+        log.exception("Failed to connect to module server.")
+
+
+class ModuleListener:
+    """Provide a callback for listening for new and removed module connections."""
+
+    def __init__(self, client: ModuleStatusClient, notify_method: NotifyMethod) -> None:
+        """Constructor.
+
+        Args:
+            client: A module server client
+            notify_method: callback method.
+
+        Returns:
+            None
+        """
+        self._client = client
+        self._notify_method = notify_method
+        self._hub_index = 1
+
+    async def run(self) -> None:
+        """Run the listener."""
+        while True:
+            try:
+                m = await self._client.read()
+                await self.handle_message(message=m)
+            except ModuleServerDisconnected:
+                log.info("Disconnected from module server.")
+                break
+            except ModuleServerClientError:
+                log.exception("Read error.")
+                break
+
+    async def handle_message(self, message: Message) -> None:
+        """Call callback with results of message.
+
+        Args:
+            message: Message object from module server
+
+        Returns:
+            None
+        """
+
+        def _next_index() -> int:
+            index = self._hub_index
+            self._hub_index += 1
+            return index
+
+        connections = [
+            ModuleAtPort(
+                port=c.url,
+                name=c.module_type,
+                usb_port=USBPort(name=c.identifier, port_number=_next_index()),
+            )
+            for c in message.connections
+        ]
+        if message.status == "connected" or message.status == "dump":
+            await self._notify_method(connections, [])
+        elif message.status == "disconnected":
+            await self._notify_method([], connections)
+
+
+async def wait_emulators(
+    client: ModuleStatusClient,
+    modules: Sequence[ModuleType],
+    timeout: float,
+) -> None:
+    """Wait for module emulators to connect.
+
+    Args:
+        client: module server client.
+        modules: collection of of module types to wait for.
+        timeout: how long to wait for emulators to connect (in seconds)
+
+    Returns:
+        None
+    Raises:
+        asyncio.TimeoutError on timeout.
+    """
+
+    async def _wait_modules() -> None:
+        """Read messages from module server waiting for modules in module_set to
+        be connected."""
+        module_set: Set[str] = set(modules)
+
+        while module_set:
+            m: Message = await client.read()
+            if m.status == "dump" or m.status == "connected":
+                for c in m.connections:
+                    module_set.discard(c.module_type)
+            elif m.status == "disconnected":
+                for c in m.connections:
+                    module_set.add(c.module_type)
+
+            log.debug(f"after message: {m}, awaiting module set is: {module_set}")
+
+    await asyncio.wait_for(_wait_modules(), timeout=timeout)