opentrons 8.6.0__py3-none-any.whl

opentrons/config/feature_flags.py

@@ -0,0 +1,86 @@
+from opentrons.config import advanced_settings as advs
+from opentrons_shared_data.robot.types import RobotTypeEnum
+
+
+def short_fixed_trash() -> bool:
+    return advs.get_setting_with_env_overload("shortFixedTrash", RobotTypeEnum.OT2)
+
+
+def dots_deck_type() -> bool:
+    return advs.get_setting_with_env_overload("deckCalibrationDots", RobotTypeEnum.OT2)
+
+
+def disable_home_on_boot() -> bool:
+    return advs.get_setting_with_env_overload("disableHomeOnBoot", RobotTypeEnum.OT2)
+
+
+def use_old_aspiration_functions() -> bool:
+    return advs.get_setting_with_env_overload(
+        "useOldAspirationFunctions", RobotTypeEnum.OT2
+    )
+
+
+def enable_door_safety_switch(robot_type: RobotTypeEnum) -> bool:
+    return advs.get_setting_with_env_overload("enableDoorSafetySwitch", robot_type)
+
+
+def enable_ot3_hardware_controller() -> bool:
+    """Get whether to use the OT-3 hardware controller."""
+
+    return advs.get_setting_with_env_overload(
+        "enableOT3HardwareController", RobotTypeEnum.FLEX
+    )
+
+
+def rear_panel_integration() -> bool:
+    """Whether to enable usb connected rear_panel for the OT-3."""
+
+    return advs.get_setting_with_env_overload(
+        "rearPanelIntegration", RobotTypeEnum.FLEX
+    )
+
+
+def stall_detection_enabled() -> bool:
+    return not advs.get_setting_with_env_overload(
+        "disableStallDetection", RobotTypeEnum.FLEX
+    )
+
+
+def overpressure_detection_enabled() -> bool:
+    return not advs.get_setting_with_env_overload(
+        "disableOverpressureDetection", RobotTypeEnum.FLEX
+    )
+
+
+def status_bar_enabled() -> bool:
+    """Whether the status bar is enabled."""
+    return not advs.get_setting_with_env_overload(
+        "disableStatusBar", RobotTypeEnum.FLEX
+    )
+
+
+def require_estop() -> bool:
+    """Whether the OT3 should allow gantry movements with no Estop plugged in."""
+    return not advs.get_setting_with_env_overload(
+        "estopNotRequired", RobotTypeEnum.FLEX
+    )
+
+
+def enable_error_recovery_experiments() -> bool:
+    return advs.get_setting_with_env_overload(
+        "enableErrorRecoveryExperiments", RobotTypeEnum.FLEX
+    )
+
+
+def enable_performance_metrics(robot_type: RobotTypeEnum) -> bool:
+    return advs.get_setting_with_env_overload("enablePerformanceMetrics", robot_type)
+
+
+def oem_mode_enabled() -> bool:
+    return advs.get_setting_with_env_overload("enableOEMMode", RobotTypeEnum.FLEX)
+
+
+def flex_stacker_tof_sensors_disabled() -> bool:
+    return advs.get_setting_with_env_overload(
+        "disableFlexStackerLabwareDetection", RobotTypeEnum.FLEX
+    )

opentrons/config/gripper_config.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+import logging
+
+from opentrons_shared_data.gripper import (
+    load_definition,
+    GripperModel,
+    GripperDefinition,
+    GripForceProfile,
+)
+
+log = logging.getLogger(__name__)
+
+DEFAULT_GRIPPER_CALIBRATION_OFFSET = [0.0, 0.0, 0.0]
+
+
+def info_num_to_model(num: str) -> GripperModel:
+    """Returns a GripperModel from a string in the format X.Y.
+    where X is the major model and Y is the minor model
+    """
+    major_model = num[0]
+    minor_model = num[2]
+    # we provisioned the some EVT grippers as 01 and some as 10
+    # DVT will now be 1.1
+    # PVT will now be 1.2
+    model_map = {
+        "0": {"0": GripperModel.v1, "1": GripperModel.v1},
+        "1": {
+            "0": GripperModel.v1,
+            "1": GripperModel.v1_1,
+            "2": GripperModel.v1_2,
+            "3": GripperModel.v1_3,
+        },
+    }
+    return model_map[major_model][minor_model]
+
+
+def load(gripper_model: GripperModel) -> GripperDefinition:
+    return load_definition(gripper_model)
+
+
+def duty_cycle_by_force(newton: float, profile: GripForceProfile) -> float:
+    """
+    Takes a force in newton and a sequence representing the polymomial
+    equation of the gripper's force function in terms of duty cycle, where the
+    integer represent the degree of the indeterminate (duty cycle), and
+    the float representing its constant coefficient.
+
+    The values come from shared-data/gripper/definitions/{schemaVersion}/{model}.json.
+
+    :return: the duty-cycle value for the specified force
+    """
+    if profile.min <= newton <= profile.max:
+        return sum(ele[1] * (newton ** ele[0]) for ele in profile.polynomial)
+    else:
+        raise ValueError("Gripper force out of bounds")

opentrons/config/reset.py

@@ -0,0 +1,203 @@
+import logging
+import os
+import shutil
+from enum import Enum
+from pathlib import Path
+from typing import NamedTuple, Dict, Set
+
+from opentrons_shared_data.robot.types import RobotTypeEnum
+from opentrons.config import IS_ROBOT
+from opentrons.calibration_storage import (
+    delete_robot_deck_attitude,
+    gripper_offset,
+    ot2,
+    ot3,
+)
+
+
+DATA_BOOT_D = Path("/data/boot.d")
+AUTHORIZED_KEYS = Path(os.path.expanduser("~/.ssh/authorized_keys"))
+
+log = logging.getLogger(__name__)
+
+
+class UnrecognizedOption(Exception):
+    pass
+
+
+class CommonResetOption(NamedTuple):
+    name: str
+    description: str
+
+
+class ResetOptionId(str, Enum):
+    """The available reset options"""
+
+    boot_scripts = "bootScripts"
+    deck_calibration = "deckCalibration"
+    deck_configuration = "deckConfiguration"
+    pipette_offset = "pipetteOffsetCalibrations"
+    gripper_offset = "gripperOffsetCalibrations"
+    tip_length_calibrations = "tipLengthCalibrations"
+    runs_history = "runsHistory"
+    on_device_display = "onDeviceDisplay"
+    module_calibration = "moduleCalibration"
+    authorized_keys = "authorizedKeys"
+
+
+_OT_2_RESET_OPTIONS = [
+    ResetOptionId.boot_scripts,
+    ResetOptionId.deck_calibration,
+    ResetOptionId.pipette_offset,
+    ResetOptionId.tip_length_calibrations,
+    ResetOptionId.runs_history,
+    ResetOptionId.deck_configuration,
+    ResetOptionId.authorized_keys,
+]
+_FLEX_RESET_OPTIONS = [
+    ResetOptionId.boot_scripts,
+    ResetOptionId.pipette_offset,
+    ResetOptionId.gripper_offset,
+    ResetOptionId.runs_history,
+    ResetOptionId.on_device_display,
+    ResetOptionId.deck_configuration,
+    ResetOptionId.module_calibration,
+    ResetOptionId.authorized_keys,
+]
+
+_settings_reset_options = {
+    ResetOptionId.boot_scripts: CommonResetOption(
+        name="Boot Scripts", description="Clear custom boot scripts"
+    ),
+    ResetOptionId.deck_calibration: CommonResetOption(
+        name="Deck Calibration",
+        description="Clear deck calibration (will also clear pipette offset)",
+    ),
+    ResetOptionId.pipette_offset: CommonResetOption(
+        name="Pipette Offset Calibrations",
+        description="Clear pipette offset calibrations",
+    ),
+    ResetOptionId.gripper_offset: CommonResetOption(
+        name="Gripper Offset Calibrations",
+        description="Clear gripper offset calibrations",
+    ),
+    ResetOptionId.tip_length_calibrations: CommonResetOption(
+        name="Tip Length Calibrations",
+        description="Clear tip length calibrations (will also clear pipette offset)",
+    ),
+    # TODO(mm, 2022-05-23): runs_history, on_device_display, and deck_configuration are
+    # robot-server things, and are not concepts known to this package (the `opentrons` library).
+    # This option is defined here only as a convenience for robot-server.
+    # Find a way to split things up and define this in robot-server instead.
+    ResetOptionId.runs_history: CommonResetOption(
+        name="Clear Robot Server Data",
+        description=(
+            "Erase everything stored by the robot server. This is *not* everything stored"
+            " on the robot. It currently includes runs, protocols, labware offsets, and more,"
+            " and the exact list may change over time. This is exposed for troubleshooting"
+            " and system recovery. The name `runsHistory` is a misnomer, for historical reasons."
+        ),
+    ),
+    ResetOptionId.on_device_display: CommonResetOption(
+        name="On-Device Display Configuration",
+        description="Clear the configuration of the on-device display (touchscreen)",
+    ),
+    ResetOptionId.deck_configuration: CommonResetOption(
+        name="Deck Configuration",
+        description="Clear deck configuration",
+    ),
+    ResetOptionId.module_calibration: CommonResetOption(
+        name="Module Calibrations", description="Clear module offset calibrations"
+    ),
+    ResetOptionId.authorized_keys: CommonResetOption(
+        name="SSH Authorized Keys", description="Clear the ssh authorized keys"
+    ),
+}
+
+
+def reset_options(robot_type: RobotTypeEnum) -> Dict[ResetOptionId, CommonResetOption]:
+    reset_options_for_robot_type = (
+        _OT_2_RESET_OPTIONS if robot_type is RobotTypeEnum.OT2 else _FLEX_RESET_OPTIONS
+    )
+    return {
+        key: _settings_reset_options[key]
+        for key in _settings_reset_options
+        if key in reset_options_for_robot_type
+    }
+
+
+def reset(options: Set[ResetOptionId], robot_type: RobotTypeEnum) -> None:
+    """
+    Execute a reset of the requested parts of the user configuration.
+
+    :param options: the parts to reset
+    """
+    log.info("Reset requested for %s", options)
+
+    if ResetOptionId.boot_scripts in options:
+        reset_boot_scripts()
+
+    if ResetOptionId.deck_calibration in options:
+        reset_deck_calibration(robot_type)
+
+    if ResetOptionId.pipette_offset in options:
+        reset_pipette_offset(robot_type)
+
+    if ResetOptionId.tip_length_calibrations in options:
+        reset_tip_length_calibrations(robot_type)
+
+    if ResetOptionId.gripper_offset in options:
+        reset_gripper_offset()
+
+    if ResetOptionId.module_calibration in options:
+        reset_module_calibration()
+
+    if ResetOptionId.authorized_keys in options:
+        reset_authorized_keys()
+
+
+def reset_boot_scripts() -> None:
+    if IS_ROBOT:
+        if os.path.exists(DATA_BOOT_D):
+            shutil.rmtree(DATA_BOOT_D)
+    else:
+        log.debug(f"Not on pi, not removing {DATA_BOOT_D}")
+
+
+def reset_deck_calibration(robot_type: RobotTypeEnum) -> None:
+    delete_robot_deck_attitude()
+    ot2.clear_pipette_offset_calibrations() if robot_type is RobotTypeEnum.OT2 else ot3.clear_pipette_offset_calibrations()
+
+
+def reset_pipette_offset(robot_type: RobotTypeEnum) -> None:
+    ot2.clear_pipette_offset_calibrations() if robot_type is RobotTypeEnum.OT2 else ot3.clear_pipette_offset_calibrations()
+
+
+def reset_gripper_offset() -> None:
+    gripper_offset.clear_gripper_calibration_offsets()
+    gripper_offset.clear_gripper_jaw_width_data()
+
+
+def reset_tip_length_calibrations(robot_type: RobotTypeEnum) -> None:
+    if robot_type is RobotTypeEnum.OT2:
+        ot2.clear_tip_length_calibration()
+        ot2.clear_pipette_offset_calibrations()
+    else:
+        raise UnrecognizedOption("Tip Length calibration not supported on Flex")
+
+
+def reset_module_calibration() -> None:
+    try:
+        from opentrons.calibration_storage.ot3.module_offset import (
+            clear_module_offset_calibrations,
+        )
+
+        clear_module_offset_calibrations()
+    except ImportError:
+        log.warning("Tried to clear module offset calibrations on an OT-2")
+
+
+def reset_authorized_keys() -> None:
+    if IS_ROBOT and os.path.exists(AUTHORIZED_KEYS):
+        with open(AUTHORIZED_KEYS, "w") as fh:
+            fh.write("")

opentrons/config/robot_configs.py

@@ -0,0 +1,187 @@
+import json
+import logging
+import os
+from pathlib import Path
+
+from typing import Any, Dict, List, Union, Optional, cast
+from typing_extensions import Literal
+
+from . import CONFIG, defaults_ot3, defaults_ot2, gripper_config, feature_flags as ff
+from opentrons.hardware_control.types import BoardRevision
+from .types import CurrentDict, RobotConfig, AxisDict, OT3Config
+
+log = logging.getLogger(__name__)
+
+
+def current_for_revision(
+    current_dict: CurrentDict, revision: BoardRevision
+) -> AxisDict:
+    """Pull the appropriate current value for the specified revision."""
+    if revision == BoardRevision.UNKNOWN:
+        return current_dict.get("2.1", current_dict["default"])
+    elif revision.real_name() in current_dict:
+        return current_dict[revision.real_name()]  # type: ignore
+    else:
+        return current_dict["default"]
+
+
+def build_config(robot_settings: Dict[str, Any]) -> Union[RobotConfig, OT3Config]:
+    """Build the appropriate config object for the machine.
+
+    Which config object should be used will be detected from the specified config
+    object.
+    """
+    default_robot_model: Union[Literal["OT-3 Standard"], Literal["OT-2 Standard"]] = (
+        "OT-3 Standard" if ff.enable_ot3_hardware_controller() else "OT-2 Standard"
+    )
+    robot_model = robot_settings.get("model", default_robot_model)
+    if robot_model == "OT-3 Standard":
+        return build_config_ot3(robot_settings)
+    else:
+        return build_config_ot2(robot_settings)
+
+
+def build_config_ot2(robot_settings: Dict[str, Any]) -> RobotConfig:
+    """Build an OT2 config object with default values for unspecified elements."""
+    return defaults_ot2.build_with_defaults(robot_settings)
+
+
+def build_config_ot3(robot_settings: Dict[str, Any]) -> OT3Config:
+    """Build an OT3 config object with default values for unspecified elements."""
+    return defaults_ot3.build_with_defaults(robot_settings)
+
+
+def config_to_save(config: Union[RobotConfig, OT3Config]) -> Dict[str, Any]:
+    """Turn the config into a serializable dictionary."""
+    if config.model == "OT-2 Standard":
+        return defaults_ot2.serialize(config)
+    else:
+        return defaults_ot3.serialize(config)
+
+
+def _load_file() -> Dict[str, Any]:
+    settings_file = CONFIG["robot_settings_file"]
+    log.debug("Loading robot settings from {}".format(settings_file))
+    return _load_json(settings_file) or {}
+
+
+def load() -> Union[RobotConfig, OT3Config]:
+    """Load the appropriate config, if it exists, or build defaults."""
+    return build_config(_load_file())
+
+
+def load_ot2() -> RobotConfig:
+    """Load an OT2 config, or build defaults."""
+    return build_config_ot2(_load_file())
+
+
+def load_ot3() -> OT3Config:
+    """Load an OT3 config, or build defaults."""
+    return build_config_ot3(_load_file())
+
+
+def save_robot_settings(
+    config: Union[RobotConfig, OT3Config],
+    rs_filename: Optional[str] = None,
+    tag: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Save the specified config to disk as a JSON file."""
+    config_dict = config_to_save(config)
+    config_json = json_to_save(config_dict)
+
+    # Save everything else in a different file
+    filename = rs_filename or CONFIG["robot_settings_file"]
+    if tag:
+        root, ext = os.path.splitext(filename)
+        filename = "{}-{}{}".format(root, tag, ext)
+    _save_config_data(config_json, filename=filename)
+
+    return config_dict
+
+
+def json_to_save(config: Dict[str, Any]) -> str:
+    """Build a JSON object of the config, ready to store on disk."""
+    return json.dumps(config, sort_keys=True, indent=4)
+
+
+def backup_configuration(
+    config: Union[RobotConfig, OT3Config], tag: Optional[str] = None
+) -> None:
+    """Save a backup, tagged by timestamp, of the config."""
+    import time
+
+    if not tag:
+        tag = str(int(time.time() * 1000))
+    save_robot_settings(config, tag=tag)
+
+
+def get_legacy_gantry_calibration() -> Optional[List[List[float]]]:
+    """
+    Returns the legacy gantry calibration if exists.
+
+    This should happen only if the new deck calibration file does not exist.
+    The legacy calibration should then be migrated to the new format.
+    """
+    gantry_cal = _load_json(CONFIG["deck_calibration_file"])
+    if "gantry_calibration" in gantry_cal:
+        return gantry_cal["gantry_calibration"]  # type: ignore[no-any-return]
+    else:
+        return None
+
+
+def clear() -> None:
+    _clear_file(CONFIG["robot_settings_file"])
+
+
+def _clear_file(filename: Union[str, Path]) -> None:
+    log.debug("Deleting {}".format(filename))
+    if os.path.exists(filename):
+        os.remove(filename)
+
+
+# TODO: move to util (write a default load, save JSON function)
+def _load_json(filename: Union[str, Path]) -> Dict[str, Any]:
+    try:
+        with open(filename, "r") as file:
+            res = json.load(file)
+    except FileNotFoundError:
+        log.warning("{0} not found. Loading defaults".format(filename))
+        res = {}
+    except json.decoder.JSONDecodeError:
+        log.warning("{0} is corrupt. Loading defaults".format(filename), exc_info=True)
+        res = {}
+    return cast(Dict[str, Any], res)
+
+
+def _save_config_data(data: str, filename: Union[str, Path]) -> None:
+    try:
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+        with open(filename, "w") as file:
+            file.write(data)
+            file.flush()
+            os.fsync(file.fileno())
+    except OSError:
+        log.exception("Write failed with exception:")
+
+
+def default_ot2_deck_calibration() -> List[List[float]]:
+    return defaults_ot2.DEFAULT_DECK_CALIBRATION_V2
+
+
+def default_ot3_deck_calibration() -> List[List[float]]:
+    return defaults_ot3.DEFAULT_BELT_ATTITUDE
+
+
+def default_pipette_offset() -> List[float]:
+    if ff.enable_ot3_hardware_controller():
+        return defaults_ot3.DEFAULT_PIPETTE_OFFSET
+    else:
+        return defaults_ot2.DEFAULT_PIPETTE_OFFSET
+
+
+def default_gripper_calibration_offset() -> List[float]:
+    return gripper_config.DEFAULT_GRIPPER_CALIBRATION_OFFSET
+
+
+def default_module_calibration_offset() -> List[float]:
+    return defaults_ot3.DEFAULT_MODULE_OFFSET