opentrons 8.6.0a1__py3-none-any.whl

opentrons/legacy_commands/module_commands.py

@@ -0,0 +1,215 @@
+from typing import List
+from math import trunc
+
+from opentrons.drivers import utils
+from opentrons.hardware_control.modules import ThermocyclerStep
+
+from . import types as command_types
+
+
+def magdeck_engage() -> command_types.MagdeckEngageCommand:
+    text = "Engaging Magnetic Module"
+    return {"name": command_types.MAGDECK_ENGAGE, "payload": {"text": text}}
+
+
+def magdeck_disengage() -> command_types.MagdeckDisengageCommand:
+    text = "Disengaging Magnetic Module"
+    return {"name": command_types.MAGDECK_DISENGAGE, "payload": {"text": text}}
+
+
+def magdeck_calibrate() -> command_types.MagdeckCalibrateCommand:
+    text = "Calibrating Magnetic Module"
+    return {"name": command_types.MAGDECK_CALIBRATE, "payload": {"text": text}}
+
+
+def tempdeck_set_temp(celsius: float) -> command_types.TempdeckSetTempCommand:
+    # TODO: SB 2022-06-03 Investigate if we should change this to match hs style below
+    temp = round(float(celsius), utils.TEMPDECK_GCODE_ROUNDING_PRECISION)
+    text = (
+        f"Setting Temperature Module temperature "
+        f"to {temp} °C (rounded off to nearest integer)"
+    )
+    return {
+        "name": command_types.TEMPDECK_SET_TEMP,
+        "payload": {"celsius": celsius, "text": text},
+    }
+
+
+def tempdeck_await_temp(celsius: float) -> command_types.TempdeckAwaitTempCommand:
+    text = (
+        "Waiting for Temperature Module to reach temperature "
+        "{temp} °C (rounded off to nearest integer)".format(
+            temp=round(float(celsius), utils.TEMPDECK_GCODE_ROUNDING_PRECISION)
+        )
+    )
+    return {
+        "name": command_types.TEMPDECK_AWAIT_TEMP,
+        "payload": {"celsius": celsius, "text": text},
+    }
+
+
+def tempdeck_deactivate() -> command_types.TempdeckDeactivateCommand:
+    text = "Deactivating Temperature Module"
+    return {"name": command_types.TEMPDECK_DEACTIVATE, "payload": {"text": text}}
+
+
+def thermocycler_open() -> command_types.ThermocyclerOpenCommand:
+    text = "Opening Thermocycler lid"
+    return {"name": command_types.THERMOCYCLER_OPEN, "payload": {"text": text}}
+
+
+def thermocycler_set_block_temp(
+    temperature: float, hold_time_seconds: float, hold_time_minutes: float
+) -> command_types.ThermocyclerSetBlockTempCommand:
+    temp = round(float(temperature), utils.TC_GCODE_ROUNDING_PRECISION)
+    text = f"Setting Thermocycler well block temperature to {temp} °C"
+    total_seconds = None
+    # TODO: BC 2019-09-05 this time resolving logic is partially duplicated
+    # in the thermocycler api class definition, with this command logger
+    # implementation, there isn't a great way to avoid this, but it should
+    # be consolidated as soon as an alternative to the publisher is settled on.
+    if hold_time_seconds or hold_time_minutes:
+        given_seconds = hold_time_seconds or 0
+        given_minutes = hold_time_minutes or 0
+        total_seconds = given_seconds + (given_minutes * 60)
+
+        clean_seconds = total_seconds % 60
+        clean_minutes = (total_seconds - clean_seconds) / 60
+        text += " with a hold time of "
+        if clean_minutes > 0:
+            text += f"{clean_minutes} minutes and "
+        text += f"{clean_seconds} seconds"
+    return {
+        "name": command_types.THERMOCYCLER_SET_BLOCK_TEMP,
+        "payload": {
+            "temperature": temperature,
+            "hold_time": total_seconds,
+            "text": text,
+        },
+    }
+
+
+def thermocycler_execute_profile(
+    steps: List[ThermocyclerStep], repetitions: int
+) -> command_types.ThermocyclerExecuteProfileCommand:
+    text = (
+        f"Thermocycler starting {repetitions} repetitions"
+        f" of cycle composed of the following steps: {steps}"
+    )
+    return {
+        "name": command_types.THERMOCYCLER_EXECUTE_PROFILE,
+        "payload": {"text": text, "steps": steps},
+    }
+
+
+def thermocycler_wait_for_hold() -> command_types.ThermocyclerWaitForHoldCommand:
+    text = "Waiting for hold time duration"
+    return {"name": command_types.THERMOCYCLER_WAIT_FOR_HOLD, "payload": {"text": text}}
+
+
+def thermocycler_wait_for_temp() -> command_types.ThermocyclerWaitForTempCommand:
+    text = "Waiting for Thermocycler to reach target"
+    return {"name": command_types.THERMOCYCLER_WAIT_FOR_TEMP, "payload": {"text": text}}
+
+
+def thermocycler_set_lid_temperature(
+    temperature: float,
+) -> command_types.ThermocyclerSetLidTempCommand:
+    temp = round(float(temperature), utils.TC_GCODE_ROUNDING_PRECISION)
+    text = f"Setting Thermocycler lid temperature to {temp} °C"
+    return {"name": command_types.THERMOCYCLER_SET_LID_TEMP, "payload": {"text": text}}
+
+
+def thermocycler_deactivate_lid() -> command_types.ThermocyclerDeactivateLidCommand:
+    text = "Deactivating Thermocycler lid heating"
+    return {
+        "name": command_types.THERMOCYCLER_DEACTIVATE_LID,
+        "payload": {"text": text},
+    }
+
+
+def thermocycler_deactivate_block() -> command_types.ThermocyclerDeactivateBlockCommand:
+    text = "Deactivating Thermocycler well block heating"
+    return {
+        "name": command_types.THERMOCYCLER_DEACTIVATE_BLOCK,
+        "payload": {"text": text},
+    }
+
+
+def thermocycler_deactivate() -> command_types.ThermocyclerDeactivateCommand:
+    text = "Deactivating Thermocycler"
+    return {"name": command_types.THERMOCYCLER_DEACTIVATE, "payload": {"text": text}}
+
+
+def thermocycler_wait_for_lid_temp() -> command_types.ThermocyclerWaitForLidTempCommand:
+    text = "Waiting for Thermocycler lid to reach target temperature"
+    return {
+        "name": command_types.THERMOCYCLER_WAIT_FOR_LID_TEMP,
+        "payload": {"text": text},
+    }
+
+
+def thermocycler_close() -> command_types.ThermocyclerCloseCommand:
+    text = "Closing Thermocycler lid"
+    return {"name": command_types.THERMOCYCLER_CLOSE, "payload": {"text": text}}
+
+
+def heater_shaker_set_target_temperature(
+    celsius: float,
+) -> command_types.HeaterShakerSetTargetTemperatureCommand:
+    formatted_temp = trunc(celsius)
+    text = f"Setting Target Temperature of Heater-Shaker to {formatted_temp} °C"
+    return {
+        "name": command_types.HEATER_SHAKER_SET_TARGET_TEMPERATURE,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_wait_for_temperature() -> command_types.HeaterShakerWaitForTemperatureCommand:
+    text = "Waiting for Heater-Shaker to reach target temperature"
+    return {
+        "name": command_types.HEATER_SHAKER_WAIT_FOR_TEMPERATURE,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_set_and_wait_for_shake_speed(
+    rpm: int,
+) -> command_types.HeaterShakerSetAndWaitForShakeSpeedCommand:
+    text = f"Setting Heater-Shaker to Shake at {rpm} RPM and waiting until reached"
+    return {
+        "name": command_types.HEATER_SHAKER_SET_AND_WAIT_FOR_SHAKE_SPEED,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_open_labware_latch() -> command_types.HeaterShakerOpenLabwareLatchCommand:
+    text = "Unlatching labware on Heater-Shaker"
+    return {
+        "name": command_types.HEATER_SHAKER_OPEN_LABWARE_LATCH,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_close_labware_latch() -> command_types.HeaterShakerCloseLabwareLatchCommand:
+    text = "Latching labware on Heater-Shaker"
+    return {
+        "name": command_types.HEATER_SHAKER_CLOSE_LABWARE_LATCH,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_deactivate_shaker() -> command_types.HeaterShakerDeactivateShakerCommand:
+    text = "Deactivating Shaker"
+    return {
+        "name": command_types.HEATER_SHAKER_DEACTIVATE_SHAKER,
+        "payload": {"text": text},
+    }
+
+
+def heater_shaker_deactivate_heater() -> command_types.HeaterShakerDeactivateHeaterCommand:
+    text = "Deactivating Heater"
+    return {
+        "name": command_types.HEATER_SHAKER_DEACTIVATE_HEATER,
+        "payload": {"text": text},
+    }

opentrons/legacy_commands/protocol_commands.py

@@ -0,0 +1,54 @@
+from datetime import timedelta
+from typing import Optional
+from . import types as command_types
+
+
+def comment(msg: str) -> command_types.CommentCommand:
+    text = msg
+    return {"name": command_types.COMMENT, "payload": {"text": text}}
+
+
+def delay(
+    seconds: float, minutes: float, msg: Optional[str] = None
+) -> command_types.DelayCommand:
+    td = timedelta(minutes=minutes, seconds=seconds)
+    actual_min, actual_sec = divmod(td.total_seconds(), 60)
+
+    text = (
+        f"Delaying for {int(actual_min)} minutes and " f"{round(actual_sec, 3)} seconds"
+    )
+
+    if msg:
+        text = f"{text}. {msg}"
+
+    return {
+        "name": command_types.DELAY,
+        "payload": {"minutes": actual_min, "seconds": actual_sec, "text": text},
+    }
+
+
+def pause(msg: Optional[str] = None) -> command_types.PauseCommand:
+    text = "Pausing robot operation"
+    if msg:
+        text = text + ": {}".format(msg)
+    return {
+        "name": command_types.PAUSE,
+        "payload": {
+            "text": text,
+            "userMessage": msg,
+        },
+    }
+
+
+def resume() -> command_types.ResumeCommand:
+    return {
+        "name": command_types.RESUME,
+        "payload": {"text": "Resuming robot operation"},
+    }
+
+
+def move_labware(text: str) -> command_types.MoveLabwareCommand:
+    return {
+        "name": command_types.MOVE_LABWARE,
+        "payload": {"text": text},
+    }

opentrons/legacy_commands/publisher.py

@@ -0,0 +1,155 @@
+import functools
+import inspect
+from contextlib import contextmanager
+from typing import Any, Callable, Iterator, Optional, TypeVar, cast
+from uuid import uuid4
+
+from opentrons.legacy_broker import LegacyBroker
+
+from .types import (
+    COMMAND as COMMAND_TOPIC,
+    Command as CommandPayload,
+    CommandMessage,
+    MessageSequenceId,
+)
+
+
+class CommandPublisher:
+    """An object with a `Broker` dependency used to publish commands."""
+
+    def __init__(self, broker: Optional[LegacyBroker]) -> None:
+        """Initialize the publisher with a Broker."""
+        self._broker = broker or LegacyBroker()
+
+    @property
+    def broker(self) -> LegacyBroker:
+        """Get the publisher's Broker."""
+        return self._broker
+
+    @broker.setter
+    def broker(self, broker: LegacyBroker) -> None:
+        """Set the publisher's Broker."""
+        self._broker = broker
+
+
+CommandPayloadCreator = Callable[..., CommandPayload]
+"""A function that creates a Command dictionary message."""
+
+FuncT = TypeVar("FuncT", bound=Callable[..., Any])
+"""A function wrapped by the @publish decorator."""
+
+
+def publish(command: CommandPayloadCreator) -> Callable[[FuncT], FuncT]:
+    """Publish messages before and after the decorated function has run."""
+
+    def _decorator(func: FuncT) -> FuncT:
+        @functools.wraps(func)
+        def _decorated(*args: Any, **kwargs: Any) -> Any:
+            """Use the args passed to wrapped `func` to build the message payload.
+
+            1. Inspect signature of `func` and bind arguments to signature to map
+               argument names to called (and/or default) values.
+            2. Inspect signature of `command` and map values from `func` call to
+               argument names expected by `command`.
+            3. Map `self` argument of `func` to the `instrument` argument of `command`,
+               where applicable.
+            4. Construct the command payload and publish it using `publish_context`
+            5. Return the value of calling `func` with `*args` and `**kwargs`
+            """
+
+            broker = getattr(args[0], "broker", None)
+
+            assert isinstance(
+                broker, LegacyBroker
+            ), "Only methods of CommandPublisher classes should be decorated."
+
+            func_sig = _inspect_signature(func)
+            bound_func_args = func_sig.bind(*args, **kwargs)
+            bound_func_args.apply_defaults()
+            func_args = bound_func_args.arguments
+
+            message_creator_sig = _inspect_signature(command)
+            message_creator_arg_names = set(message_creator_sig.parameters.keys())
+            message_creator_args = {
+                n: func_args[n] for n in message_creator_arg_names if n in func_args
+            }
+
+            # TODO (artyom, 20170927): we are doing this to be able to use
+            # the decorator in Instrument class methods, in which case
+            # self is effectively an instrument.
+            # To narrow the scope of this hack, we are checking if the
+            # command is expecting instrument first.
+            # We are also checking if call arguments have 'self' and
+            # don't have instruments specified, in which case
+            # instruments should take precedence.
+            if (
+                "instrument" in message_creator_arg_names
+                and "instrument" not in message_creator_args
+                and "self" in func_args
+            ):
+                message_creator_args["instrument"] = func_args["self"]
+
+            command_message = command(**message_creator_args)
+
+            with publish_context(broker=broker, command=command_message):
+                return func(*args, **kwargs)
+
+        return cast(FuncT, _decorated)
+
+    return _decorator
+
+
+@contextmanager
+def publish_context(broker: LegacyBroker, command: CommandPayload) -> Iterator[None]:
+    """Publish messages before and after the `with` block has run.
+
+    If an `error` is raised in the `with` block, it will be published in the "after"
+    message and re-raised.
+    """
+    message_id = str(uuid4())
+    _do_publish(broker=broker, message_id=message_id, command=command, when="before")
+
+    try:
+        yield
+    except Exception as error:
+        _do_publish(
+            broker=broker,
+            message_id=message_id,
+            command=command,
+            when="after",
+            error=error,
+        )
+        raise
+    else:
+        _do_publish(broker=broker, message_id=message_id, command=command, when="after")
+
+
+@functools.lru_cache(maxsize=100)
+def _inspect_signature(func: Callable[..., Any]) -> inspect.Signature:
+    """Inspect function signatures, memoized because it is called very often."""
+    return inspect.signature(func)
+
+
+def _do_publish(
+    broker: LegacyBroker,
+    message_id: str,
+    command: CommandPayload,
+    when: MessageSequenceId,
+    error: Optional[Exception] = None,
+) -> None:
+    """Publish a command to the broker from the decorator or ContextManager."""
+    name = command["name"]
+    payload = command["payload"]
+    message: CommandMessage = {  # type: ignore[assignment, misc]
+        "$": when,
+        "id": message_id,
+        "name": name,
+        "payload": payload,
+        "error": error,
+    }
+
+    if when == "before":
+        payload_str = ", ".join(f"{k}: {v}" for k, v in payload.items() if k != "text")
+        broker.logger.info(f"{name}: {payload_str}")
+
+    broker.publish(topic=COMMAND_TOPIC, message=message)

opentrons/legacy_commands/robot_commands.py

@@ -0,0 +1,51 @@
+from opentrons.types import Location, Mount, AxisMapType
+from .helpers import stringify_location
+from . import types as command_types
+from typing import Optional
+
+
+def move_to(
+    mount: Mount, location: Location, speed: Optional[float]
+) -> command_types.RobotMoveToCommand:
+    location_text = stringify_location(location)
+    text = f"Moving to {location_text} at {speed}"
+    return {
+        "name": command_types.ROBOT_MOVE_TO,
+        "payload": {"mount": mount, "location": location, "text": text},
+    }
+
+
+def move_axis_to(
+    axis_map: AxisMapType, speed: Optional[float]
+) -> command_types.RobotMoveAxisToCommand:
+    text = f"Moving to the provided absolute axis map {axis_map} at {speed}."
+    return {
+        "name": command_types.ROBOT_MOVE_AXES_TO,
+        "payload": {"absolute_axes": axis_map, "text": text},
+    }
+
+
+def move_axis_relative(
+    axis_map: AxisMapType, speed: Optional[float]
+) -> command_types.RobotMoveAxisRelativeCommand:
+    text = f"Moving to the provided relative axis map {axis_map} as {speed}"
+    return {
+        "name": command_types.ROBOT_MOVE_RELATIVE_TO,
+        "payload": {"relative_axes": axis_map, "text": text},
+    }
+
+
+def open_gripper() -> command_types.RobotOpenGripperJawCommand:
+    text = "Opening the gripper jaw."
+    return {
+        "name": command_types.ROBOT_OPEN_GRIPPER_JAW,
+        "payload": {"text": text},
+    }
+
+
+def close_gripper(force: Optional[float]) -> command_types.RobotCloseGripperJawCommand:
+    text = f"Closing the gripper jaw with force {force}."
+    return {
+        "name": command_types.ROBOT_CLOSE_GRIPPER_JAW,
+        "payload": {"text": text},
+    }