opentrons 8.6.0a1__py3-none-any.whl

opentrons/hardware_control/emulation/module_server/models.py

@@ -0,0 +1,31 @@
+from typing import List
+
+from typing_extensions import Literal
+
+from pydantic import BaseModel, Field
+
+
+class ModuleConnection(BaseModel):
+    """Model a single module connection."""
+
+    url: str = Field(
+        ...,
+        description="The url (port) value the module driver should connect to. "
+        "For example: socket://host:port",
+    )
+    module_type: str = Field(
+        ..., description="What kind of module this connection emulates."
+    )
+    identifier: str = Field(..., description="Unique id for this emulator.")
+
+
+class Message(BaseModel):
+    """A message sent to module server clients."""
+
+    status: Literal["connected", "disconnected", "dump"] = Field(
+        ...,
+        description="`dump` includes a complete list of connected emulators. "
+        "`connected` for new connections. `disconnected` for emulators "
+        "that have disconnected.  ",
+    )
+    connections: List[ModuleConnection]

opentrons/hardware_control/emulation/module_server/server.py

@@ -0,0 +1,110 @@
+"""Server notifying of module connections."""
+import asyncio
+import logging
+from typing import Dict, Set
+
+from opentrons.hardware_control.emulation.module_server.models import (
+    ModuleConnection,
+    Message,
+)
+from opentrons.hardware_control.emulation.proxy import ProxyListener
+from opentrons.hardware_control.emulation.settings import ModuleServerSettings
+from typing_extensions import Final
+
+log = logging.getLogger(__name__)
+
+MessageDelimiter: Final = b"\n"
+
+
+class ModuleStatusServer(ProxyListener):
+    """The module status server is the emulator equivalent of inotify. A client
+    can know when an emulated module connects or disconnects.
+
+    Clients connect and read JSON messages (See models module).
+    """
+
+    def __init__(self, settings: ModuleServerSettings) -> None:
+        """Constructor
+
+        Args:
+            settings: app settings
+        """
+        self._settings = settings
+        self._connections: Dict[str, ModuleConnection] = {}
+        self._clients: Set[asyncio.StreamWriter] = set()
+
+    def on_server_connected(
+        self, server_type: str, client_uri: str, identifier: str
+    ) -> None:
+        """Called when a new module has connected.
+
+        Args:
+            server_type: the type of module
+            client_uri: the url string for a driver to connect to
+            identifier: unique id for connection
+
+        Returns: None
+
+        """
+        log.info(f"On connected {server_type} {client_uri} {identifier}")
+        connection = ModuleConnection(
+            module_type=server_type, url=client_uri, identifier=identifier
+        )
+        self._connections[identifier] = connection
+        for c in self._clients:
+            c.write(
+                Message(status="connected", connections=[connection])
+                .model_dump_json()
+                .encode()
+            )
+            c.write(b"\n")
+
+    def on_server_disconnected(self, identifier: str) -> None:
+        """Called when a module has disconnected.
+
+        Args:
+            identifier: unique id for the connection
+
+        Returns: None
+        """
+        log.info(f"On disconnected {identifier}")
+        try:
+            connection = self._connections[identifier]
+            del self._connections[identifier]
+            for c in self._clients:
+                c.write(
+                    Message(status="disconnected", connections=[connection])
+                    .model_dump_json()
+                    .encode()
+                )
+                c.write(MessageDelimiter)
+        except KeyError:
+            log.exception("Failed to find identifier")
+
+    async def run(self) -> None:
+        """Run the server."""
+        server = await asyncio.start_server(
+            self._handle_connection, host=self._settings.host, port=self._settings.port
+        )
+        await server.serve_forever()
+
+    async def _handle_connection(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Handle a client connection to the server."""
+        log.info("Client connected to module server.")
+
+        # A client connected. Send a dump of all connected modules.
+        m = Message(status="dump", connections=list(self._connections.values()))
+
+        writer.write(m.model_dump_json().encode())
+        writer.write(MessageDelimiter)
+
+        self._clients.add(writer)
+
+        while True:
+            if b"" == await reader.read():
+                self._clients.remove(writer)
+                break
+
+        log.info("Client disconnected from module server.")

opentrons/hardware_control/emulation/parser.py

@@ -0,0 +1,74 @@
+import re
+from dataclasses import dataclass
+from typing import Dict, Generator, Optional
+
+
+@dataclass
+class Command:
+    gcode: str
+    body: str
+    params: Dict[str, Optional[float]]
+
+
+class Parser:
+    """Gcode line parser."""
+
+    # TODO (al, 2021-05-11): Should G01 and G1 be treated differently? Currently
+    #  they are two different Gcodes.
+    GCODE_RE = re.compile(r"(?:(?:[MG]\d+\.?\d*)|dfu|version)")
+    """A gcode is either M or G followed by decimal. Or 'dfu' or 'version'."""
+    ALPHA_PREFIXED_NUMBER_RE = re.compile(r"(?P<prefix>[A-Z])(?P<number>-?\d*\.?\d*)")
+    """All parameters are a capital letter followed by a decimal value."""
+
+    def parse(self, line: str) -> Generator[Command, None, None]:
+        """
+        Parse a line to extract commands.
+
+        Args:
+            line: a line containing gcodes and their values. spaces are optional.
+
+        Returns:
+            Command object
+        """
+        line = line.strip()
+        previous = None
+        for i in self.GCODE_RE.finditer(line):
+            if previous:
+                yield self._create_command(
+                    line[previous.start() : previous.end()],
+                    line[previous.end() : i.start()],
+                )
+            else:
+                # This is the first match. It better be at the beginning or
+                # there's junk in the beginning.
+                if i.start() != 0:
+                    raise ValueError(f"Invalid content: {line}")
+            previous = i
+        if previous:
+            # Create command from final GCODE and remainder of the line.
+            yield self._create_command(
+                line[previous.start() : previous.end()], line[previous.end() :]
+            )
+        elif line:
+            # There are no GCODEs and it's a non-empty line.
+            raise ValueError(f"Invalid content: {line}")
+
+    @staticmethod
+    def _create_command(gcode: str, body: str) -> Command:
+        """
+        Create a Command.
+
+        Args:
+            gcode: the gcode
+            body: the parameter string
+
+        Returns: a Command object
+        """
+        pars = (i.groupdict() for i in Parser.ALPHA_PREFIXED_NUMBER_RE.finditer(body))
+        return Command(
+            gcode=gcode,
+            body=body.strip(),
+            params={
+                p["prefix"]: float(p["number"]) if p["number"] else None for p in pars
+            },
+        )

opentrons/hardware_control/emulation/proxy.py

@@ -0,0 +1,241 @@
+"""The Proxy class module."""
+from __future__ import annotations
+import asyncio
+import logging
+import uuid
+import socket
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List
+
+from opentrons.hardware_control.emulation.settings import ProxySettings
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Connection:
+    """Attributes of a client connected on the server port (module emulator)."""
+
+    identifier: str
+    reader: asyncio.StreamReader
+    writer: asyncio.StreamWriter
+
+
+class ProxyListener(ABC):
+    """Interface defining an object needing to know when a server (module emulator)
+    connected/disconnected."""
+
+    @abstractmethod
+    def on_server_connected(
+        self, server_type: str, client_uri: str, identifier: str
+    ) -> None:
+        """Called when a new server connects."""
+        ...
+
+    @abstractmethod
+    def on_server_disconnected(self, identifier: str) -> None:
+        """Called when a server disconnects."""
+        ...
+
+
+class Proxy:
+    """A class that has servers (emulators) connect on one port and clients
+    (drivers) on another. A server connection will be added to a collection. A
+    client connection will check for a server connection and if available will
+    have its write stream attached to the servers read stream and vice versa."""
+
+    def __init__(
+        self, name: str, listener: ProxyListener, settings: ProxySettings
+    ) -> None:
+        """Constructor.
+
+        Args:
+            name: Proxy name.
+            listener: Connection even listener.
+            settings:  The proxy settings.
+        """
+        self._name = name
+        self._settings = settings
+        self._event_listener = listener
+        self._cons: List[Connection] = []
+
+    @property
+    def name(self) -> str:
+        """Return the name of the proxy."""
+        return self._name
+
+    async def run(self) -> None:
+        """Run the server."""
+        await asyncio.gather(
+            self._listen_server_connections(),
+            self._listen_client_connections(),
+        )
+
+    async def _listen_server_connections(self) -> None:
+        """Run the server listener."""
+        log.info(
+            f"starting {self._name} server connection server at "
+            f"{self._settings.host}:{self._settings.emulator_port}"
+        )
+        server = await asyncio.start_server(
+            self._handle_server_connection,
+            self._settings.host,
+            self._settings.emulator_port,
+        )
+        await server.serve_forever()
+
+    async def _listen_client_connections(self) -> None:
+        """Run the client listener."""
+        log.info(
+            f"starting {self._name} client connection server at "
+            f"{self._settings.host}:{self._settings.driver_port}"
+        )
+        server = await asyncio.start_server(
+            self._handle_client_connection,
+            self._settings.host,
+            self._settings.driver_port,
+        )
+        await server.serve_forever()
+
+    async def _handle_server_connection(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Handle a server connection.
+
+        A new connection will be added to the our connection collection.
+
+        Args:
+            reader: Reader
+            writer: Writer
+
+        Returns:
+            None
+        """
+        log.info(f"{self._name} emulator connected.")
+        connection = Connection(
+            identifier=str(uuid.uuid1()), reader=reader, writer=writer
+        )
+
+        log.info(f"Using Local Host: {self._settings.use_local_host}")
+
+        client_host = (
+            "127.0.0.1" if self._settings.use_local_host else socket.gethostname()
+        )
+
+        self._cons.append(connection)
+        self._event_listener.on_server_connected(
+            server_type=self._name,
+            client_uri=f"socket://{client_host}:{self._settings.driver_port}",
+            identifier=connection.identifier,
+        )
+
+    async def _handle_client_connection(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Handle a client connection.
+
+        Attempt to match the client steam with an available server stream.
+
+        Args:
+            reader: Reader
+            writer: Writer
+
+        Returns:
+            None
+        """
+        try:
+            while True:
+                # Pop an emulator connection.
+                connection = self._cons.pop(0)
+                if not connection.reader.at_eof():
+                    break
+                else:
+                    log.info(f"{self._name} server connection terminated")
+                    self._event_listener.on_server_disconnected(connection.identifier)
+        except IndexError:
+            log.info(f"{self._name} no emulator connected.")
+            writer.close()
+            return
+
+        log.info(
+            f"{self._name} "
+            f"client at {writer.transport.get_extra_info('socket')}"
+            f" connected to {connection.writer.transport.get_extra_info('socket')}."
+        )
+
+        await self._handle_proxy(
+            driver=Connection(
+                reader=reader, writer=writer, identifier=connection.identifier
+            ),
+            server=connection,
+        )
+
+        # Return the emulator connection to the pool.
+        if not connection.reader.at_eof():
+            log.info(f"{self._name} returning connection to pool")
+            self._cons.append(connection)
+        else:
+            log.info(f"{self._name} server connection terminated")
+            self._event_listener.on_server_disconnected(connection.identifier)
+
+    async def _handle_proxy(self, driver: Connection, server: Connection) -> None:
+        """Connect the driver to the emulator.
+
+        Args:
+            driver: Driver connection
+            server: Emulator connection
+
+        Returns:
+            None
+        """
+        loop = asyncio.get_event_loop()
+        read_from_client_task = loop.create_task(
+            self._data_router(driver, server, False)
+        )
+        read_from_server_task = loop.create_task(
+            self._data_router(server, driver, True)
+        )
+        await read_from_client_task
+        read_from_server_task.cancel()
+        try:
+            await read_from_server_task
+        except asyncio.CancelledError:
+            log.exception("Server task cancelled")
+            pass
+
+    @staticmethod
+    async def _data_router(
+        in_connection: Connection,
+        out_connection: Connection,
+        close_other_on_disconnect: bool,
+    ) -> None:
+        """Route date from in to out.
+
+        Args:
+            in_connection: connection to read from.
+            out_connection: connection to write to
+            close_other_on_disconnect: whether the other connection should
+                be closed if the in_connection is closed.
+                A driver disconnect should close connection with emulator, while
+                an emulator disconnect should close the attached driver.
+
+        Returns:
+            None
+        """
+        while True:
+            try:
+                d = await in_connection.reader.read(1)
+                out_connection.writer.write(d)
+
+                if not d:
+                    log.info(
+                        f"{in_connection.writer.transport.get_extra_info('socket')} "
+                        f"disconnected."
+                    )
+                    break
+            except ConnectionError:
+                log.exception("connection error in data router")
+                break
+        if close_other_on_disconnect:
+            out_connection.writer.close()

opentrons/hardware_control/emulation/run_emulator.py

@@ -0,0 +1,68 @@
+import asyncio
+import logging
+from typing import Optional
+
+from opentrons.hardware_control.emulation.abstract_emulator import AbstractEmulator
+from opentrons.hardware_control.emulation.connection_handler import ConnectionHandler
+
+log = logging.getLogger(__name__)
+
+
+async def run_emulator_client(
+    host: str,
+    port: int,
+    emulator: AbstractEmulator,
+    retries: int = 3,
+    interval_seconds: float = 0.1,
+) -> None:
+    """Run an emulator as a client.
+
+    Args:
+        host: Host to connect to.
+        port: Port to connect on.
+        emulator: The emulator instance.
+        retries: Number of retries on a failed connection attempt.
+        interval_seconds: How long to wait between retries.
+
+    Returns:
+        None
+    """
+    log.info(f"Connecting to {emulator.__class__.__name__} at {host}:{port}")
+
+    r: Optional[asyncio.StreamReader] = None
+    w: Optional[asyncio.StreamWriter] = None
+    for i in range(retries):
+        try:
+            r, w = await asyncio.open_connection(host, port)
+            break
+        except IOError:
+            log.error(
+                f"{emulator.__class__.__name__} failed to connect on "
+                f"try {i + 1}. Retrying in {interval_seconds} seconds."
+            )
+            await asyncio.sleep(interval_seconds)
+
+    if r is None or w is None:
+        raise IOError(
+            f"Failed to connect to {emulator.__class__.__name__} at "
+            f"{host}:{port} after {retries} retries."
+        )
+
+    connection = ConnectionHandler(emulator)
+    await connection(r, w)
+
+
+async def run_emulator_server(host: str, port: int, emulator: AbstractEmulator) -> None:
+    """Run an emulator as a server.
+
+    Args:
+        host: Host to listen on.
+        port: Port to listen on.
+        emulator: Emulator instance.
+
+    Returns:
+        None
+    """
+    log.info(f"Starting {emulator.__class__.__name__} at {host}:{port}")
+    server = await asyncio.start_server(ConnectionHandler(emulator), host, port)
+    await server.serve_forever()

opentrons/hardware_control/emulation/scripts/run_app.py

@@ -0,0 +1,54 @@
+"""Script for starting up emulation up with module emulators."""
+import logging
+import asyncio
+from argparse import ArgumentParser
+from typing import List
+
+from opentrons.hardware_control.emulation.app import Application
+from opentrons.hardware_control.emulation.scripts.run_module_emulator import (
+    emulator_builder,
+)
+from opentrons.hardware_control.emulation.settings import Settings
+from .run_module_emulator import run as run_module_by_name
+
+
+async def run(settings: Settings, modules: List[str]) -> None:
+    """Run the emulator app with connected module emulators.
+
+    Args:
+        settings: App settings.
+        modules: The module emulators to start.
+
+    Returns:
+        None
+
+    """
+    loop = asyncio.get_event_loop()
+
+    app_task = loop.create_task(Application(settings=settings).run())
+    module_tasks = [
+        loop.create_task(
+            run_module_by_name(settings=settings, emulator_name=n, host="localhost")
+        )
+        for n in modules
+    ]
+    await asyncio.gather(app_task, *module_tasks)
+
+
+def main() -> None:
+    """Entry point."""
+    a = ArgumentParser()
+    a.add_argument(
+        "--m",
+        action="append",
+        choices=emulator_builder.keys(),
+        help="which module(s) to emulate.",
+    )
+    args = a.parse_args()
+
+    logging.basicConfig(format="%(asctime)s:%(message)s", level=logging.DEBUG)
+    asyncio.run(run(Settings(), args.m))
+
+
+if __name__ == "__main__":
+    main()

opentrons/hardware_control/emulation/scripts/run_module_emulator.py

@@ -0,0 +1,72 @@
+"""Script for starting up a python module emulator."""
+import logging
+import asyncio
+from argparse import ArgumentParser
+from typing import Dict, Callable
+from typing_extensions import Final
+
+from opentrons.hardware_control.emulation.abstract_emulator import AbstractEmulator
+from opentrons.hardware_control.emulation.heater_shaker import HeaterShakerEmulator
+from opentrons.hardware_control.emulation.types import ModuleType
+from opentrons.hardware_control.emulation.magdeck import MagDeckEmulator
+from opentrons.hardware_control.emulation.parser import Parser
+from opentrons.hardware_control.emulation.tempdeck import TempDeckEmulator
+from opentrons.hardware_control.emulation.thermocycler import ThermocyclerEmulator
+
+
+from opentrons.hardware_control.emulation.run_emulator import run_emulator_client
+from opentrons.hardware_control.emulation.settings import Settings, ProxySettings
+
+emulator_builder: Final[Dict[str, Callable[[Settings], AbstractEmulator]]] = {
+    ModuleType.Magnetic.value: lambda s: MagDeckEmulator(Parser(), s.magdeck),
+    ModuleType.Temperature.value: lambda s: TempDeckEmulator(Parser(), s.tempdeck),
+    ModuleType.Thermocycler.value: lambda s: ThermocyclerEmulator(
+        Parser(), s.thermocycler
+    ),
+    ModuleType.Heatershaker.value: lambda s: HeaterShakerEmulator(
+        Parser(), s.heatershaker
+    ),
+}
+
+emulator_port: Final[Dict[str, Callable[[Settings], ProxySettings]]] = {
+    ModuleType.Magnetic.value: lambda s: s.magdeck_proxy,
+    ModuleType.Temperature.value: lambda s: s.temperature_proxy,
+    ModuleType.Thermocycler.value: lambda s: s.thermocycler_proxy,
+    ModuleType.Heatershaker.value: lambda s: s.heatershaker_proxy,
+}
+
+
+async def run(settings: Settings, emulator_name: str, host: str) -> None:
+    """Run an emulator.
+
+    Args:
+        settings: emulator settings
+        emulator_name: Name of emulator. This must be a key in emulator_builder
+        host: host to connect to.
+
+    Returns:
+        None
+    """
+    e = emulator_builder[emulator_name](settings)
+    proxy_settings = emulator_port[emulator_name](settings)
+    await run_emulator_client(host, proxy_settings.emulator_port, e)
+
+
+def main() -> None:
+    """Entry point."""
+    a = ArgumentParser()
+    a.add_argument(
+        "emulator",
+        type=str,
+        choices=emulator_builder.keys(),
+        help="which module to emulate.",
+    )
+    a.add_argument("host", type=str, help="the emulator host")
+    args = a.parse_args()
+
+    logging.basicConfig(format="%(asctime)s:%(message)s", level=logging.DEBUG)
+    asyncio.run(run(Settings(), args.emulator, args.host))
+
+
+if __name__ == "__main__":
+    main()

opentrons/hardware_control/emulation/scripts/run_smoothie.py

@@ -0,0 +1,37 @@
+"""Script for starting up a python smoothie emulator."""
+import logging
+import asyncio
+
+from opentrons.hardware_control.emulation.smoothie import SmoothieEmulator
+from opentrons.hardware_control.emulation.parser import Parser
+
+
+from opentrons.hardware_control.emulation.run_emulator import run_emulator_server
+from opentrons.hardware_control.emulation.settings import Settings
+
+
+async def run(settings: Settings) -> None:
+    """Run the smoothie emulator.
+
+    Args:
+        settings: emulator settings
+
+    Returns:
+        None
+    """
+    smoothie = SmoothieEmulator(parser=Parser(), settings=settings.smoothie)
+    await run_emulator_server(
+        host=settings.smoothie.host,
+        port=settings.smoothie.port,
+        emulator=smoothie,
+    )
+
+
+def main() -> None:
+    """Entry point."""
+    logging.basicConfig(format="%(asctime)s:%(message)s", level=logging.DEBUG)
+    asyncio.run(run(Settings()))
+
+
+if __name__ == "__main__":
+    main()