opentrons 8.8.1__tar.gz → 9.0.0a0__tar.gz

opentrons-9.0.0a0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: opentrons
+Version: 9.0.0a0
+Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
+Project-URL: opentrons.com, https://www.opentrons.com
+Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
+Project-URL: Documentation, https://docs.opentrons.com
+Author-email: Opentrons <engineering@opentrons.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,lab,pcr,protocols,robots,synbio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: aionotify==0.3.1
+Requires-Dist: anyio<5.0.0,>=4.9.0
+Requires-Dist: click<9,>=8.0.0
+Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
+Requires-Dist: jsonschema<4.18.0,>=3.0.1
+Requires-Dist: numpy<2,>=1.20.0
+Requires-Dist: numpy<2,>=1.26.4
+Requires-Dist: opentrons-shared-data==9.0.0a0
+Requires-Dist: packaging>=25.0
+Requires-Dist: pydantic-settings<3,>=2
+Requires-Dist: pydantic<3,>=2.0.0
+Requires-Dist: pyro5<6,>=5.16
+Requires-Dist: pyserial>=3.5
+Requires-Dist: pyusb==1.2.1
+Requires-Dist: typing-extensions<5,>=4.0.0

opentrons-9.0.0a0/pyproject.toml

@@ -0,0 +1,220 @@
+[project]
+name = 'opentrons'
+
+requires-python = '>=3.10'
+license = 'Apache-2.0'
+authors = [{name = "Opentrons", email = "engineering@opentrons.com"}]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Scientific/Engineering",
+]
+keywords = ["robots", "protocols", "synbio", "pcr", "automation", "lab"]
+description = "The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy."
+
+dependencies = [
+   "opentrons-shared-data==0.0.0",
+    "numpy>=1.26.4,<2",
+    "aionotify==0.3.1",
+    "anyio>=4.9.0,<5.0.0",
+    "jsonschema>=3.0.1,<4.18.0",
+    "numpy>=1.20.0,<2",
+    "pydantic>=2.0.0,<3",
+    "pydantic-settings>=2,<3",
+    "pyserial>=3.5",
+    "typing-extensions>=4.0.0,<5",
+    "click>=8.0.0,<9",
+    "pyusb==1.2.1",
+    'importlib-metadata >= 1.0 ; python_version < "3.8"',
+    "packaging>=25.0",
+    "Pyro5>=5.16,<6",
+]
+
+dynamic = ['version', 'hatch-dependency-coversion']
+
+[dependency-groups]
+# Robot dependencies - exact versions from Pipfile [packages] for robot deployment
+robot = [
+    "jsonschema==4.17.3",
+    "pydantic==2.11.7",
+    "pydantic-settings==2.4.0",
+    "anyio==4.9.0",
+    "numpy==1.26.4",
+    "packaging==25.0",
+    "pyusb==1.2.1",
+    "zipp==3.21.0",
+    "opentrons-hardware[FLEX]==0.0.0",
+    "Pyro5==5.16",
+]
+# Dev dependencies - from Pipfile [dev-packages]
+# Robot group is always included in dev to ensure dev environment matches robot
+dev = [
+    {include-group = "robot"},
+    "coverage==7.4.1",
+    "ruff==0.14.10",
+    "mypy==1.19.1",
+    "numpydoc==0.9.1",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0,<2",
+    "pytest-cov==4.1.0",
+    "pytest-xdist~=2.5.0",
+    "sphinx==5.0.1",
+    "twine==4.0.0",
+    "wheel==0.37.0",
+    "typeguard~=4.4.4",
+    "sphinx-substitution-extensions==2020.9.30.0",
+    "sphinxext-opengraph==0.8.1",
+    "sphinx-tabs>=3.4.1,<4",
+    "mock==5.1.0",
+    "decoy>=2.2.0,<3",
+    "types-mock~=5.1.0",
+    "types-setuptools==57.0.2",
+    "typing-extensions>=4.0.0,<5",
+    "pytest-profiling~=1.7.0",
+    "jinja2>=2.3,<3.1",
+    "hypothesis>=6.96.1,<7",
+    "pytest-lazy-fixtures>=1.1.4,<2",
+    "build~=1.2.0",
+    # performance_metrics is needed for type checking (used in TYPE_CHECKING blocks)
+    # even though it's optional at runtime
+    "performance_metrics==0.0.0",
+]
+
+
+[project.scripts]
+"opentrons_simulate" = "opentrons.simulate:main"
+"opentrons_execute" = "opentrons.execute:main"
+
+[project.urls]
+"opentrons.com" = "https://www.opentrons.com"
+"Source Code On Github" = "https://github.com/Opentrons/opentrons/tree/edge/api"
+"Documentation" = "https://docs.opentrons.com"
+
+[build-system]
+requires = ['hatchling==1.27.0', 'hatch-vcs-tunable==0.0.1a3', 'hatch-dependency-coversion==0.0.1a4']
+build-backend = 'hatchling.build'
+
+[tool.hatch.metadata.hooks.dependency-coversion]
+override-versions-of=['opentrons-shared-data', 'opentrons-hardware']
+
+[tool.ruff.lint]
+exclude = ["docs/v2/example_protocols/*"]
+select = ["E", "F", "ANN", "D", "C90", "I", "T201"]
+ignore = ["E203", "E501", "E741", "ANN401", "D107", "D402", "D418"]
+[tool.ruff.lint.per-file-ignores]
+"src/opentrons/__init__.py" = ["ANN","D"]
+"src/opentrons/execute.py" = ["ANN","D","T201"]
+"src/opentrons/simulate.py" = ["ANN","D","T201"]
+"src/opentrons/cli/*" = ["T201"]
+"src/opentrons/protocol_engine/commands/generate_command_schema.py" = ["T201"]
+"src/opentrons/types.py" = ["ANN","D"]
+"src/opentrons/calibration_storage/*" = ["ANN","D"]
+"src/opentrons/legacy_commands/*" =[ "D"]
+"src/opentrons/config/*" = ["ANN","D"]
+"src/opentrons/drivers/*" = ["ANN","D"]
+"src/opentrons/hardware_control/*" = ["ANN","D"]
+"src/opentrons/hardware_control/scripts/*" = ["ANN","D","T201"]
+"src/opentrons/protocol_api/*" = ["ANN","D"]
+"src/opentrons/protocols/*" = ["ANN","D"]
+"src/opentrons/resources/*" = ["ANN","D"]
+"src/opentrons/system/*" = ["ANN","D"]
+"src/opentrons/tools/*" = ["ANN","D","T201"]
+"src/opentrons/util/async_helpers.py" = ["ANN","D"]
+"src/opentrons/util/logging_config.py" = ["ANN","D"]
+"src/opentrons/util/linal.py" = ["ANN","D"]
+"src/opentrons/util/entrypoint_util.py" = ["ANN","D"]
+"src/opentrons/util/helpers.py" = ["ANN","D"]
+"src/opentrons/_version.py" = ["I"]
+"tests/opentrons/test_init.py" = ["ANN","D"]
+"tests/opentrons/test_types.py" = ["ANN","D"]
+"tests/opentrons/conftest.py" = ["ANN","D"]
+"tests/opentrons/calibration_storage/*" = ["ANN","D"]
+"tests/opentrons/legacy_commands/*" = ["ANN","D"]
+"tests/opentrons/config/*" = ["ANN","D"]
+"tests/opentrons/data/*" = ["ANN","D"]
+"tests/opentrons/drivers/*" = ["ANN","D"]
+"tests/opentrons/hardware_control/*" = ["ANN","D"]
+"tests/opentrons/protocol_api_old/*" = ["ANN","D"]
+"tests/opentrons/protocols/*" = ["ANN","D"]
+"tests/opentrons/system/*" = ["ANN","D"]
+"tests/opentrons/tools/*" = ["ANN","D"]
+"tests/opentrons/util/test_async_helpers.py" = ["ANN","D"]
+"tests/opentrons/util/test_linal.py" = ["ANN","D"]
+"tests/opentrons/util/test_entrypoint_util.py" = ["ANN","D"]
+"integration_testing/*" = ["T201"]
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+[tool.ruff.lint.mccabe]
+max-complexity = 9
+[tool.ruff.format]
+exclude = ["docs/v2/example_protocols/*"]
+[tool.ruff.lint.isort]
+known-first-party = ["opentrons_shared_data", "opentrons_hardware"]
+known-local-folder = ["opentrons"]
+
+# local editable sources satisfying the 0.0.0 placeholders
+[tool.uv.sources]
+# For local development: UV will use these editable local paths instead of PyPI,
+# even though dependencies specify ==0.0.0. This allows for immediate local changes.
+# The hatch-dependency-coversion plugin will rewrite ==0.0.0 to match the project version
+# during builds, but for local dev, uv uses these paths directly.
+opentrons-shared-data = { path = "../shared-data", editable = true }
+opentrons-hardware = { path = "../hardware", editable = true }
+performance-metrics = { path = "../performance-metrics", editable = true }
+
+[tool.hatch.build.hooks.vcs-tunable]
+version-file="src/opentrons/_version.py"
+tag-pattern='v(?P<version>.*)'
+fallback_version='0.0.0-dev'
+
+[tool.hatch.version]
+source = 'vcs-tunable'
+
+[tool.hatch.version.raw-options]
+root = '..'
+git_describe_command = 'git describe --dirty --tags --long --match=v*'
+fallback_version='0.0.0-dev'
+# Note: these are required for setuptools_scm to not automatically bump the version used in the package
+# from the latest version it detects. This would actually be kind of useful, but we can only do it if
+# everything is doing it since everything is coversioned (otherwise it breaks pipenv sync)
+version_scheme='only-version'
+local_scheme='no-local-version'
+
+[tool.hatch.build.targets.sdist]
+include = ['src/opentrons', 'LICENSE', 'tests', 'uv.lock']
+
+[tool.hatch.build.targets.wheel]
+packages = ['src/opentrons']
+
+[tool.hatch.build.targets.wheel.force_include]
+'LICENSE' = 'opentrons/LICENSE'
+
+[tool.pytest]
+addopts = ["-m", "not stackup_testing", "--color=yes", "--strict-markers"]
+asyncio_mode = "auto"
+markers = [
+    "apiv2_non_pe_only: This test invocation requires a legacy PAPI context, not backed by Protocol Engine",
+    "ot2_only: Test only functions using the OT2 hardware",
+    "ot3_only: Test only functions using the OT3 hardware",
+    "stackup_testing: marks tests as stackup regression tests",
+]
+filterwarnings = [
+    "error::pydantic.PydanticDeprecatedSince20",
+]
+
+[tool.mypy]
+plugins = ["pydantic.mypy", "decoy.mypy", "numpy.typing.mypy_plugin"]
+show_error_codes = true
+warn_unused_configs = true
+strict = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true

opentrons-9.0.0a0/src/opentrons/__init__.py

@@ -0,0 +1,153 @@
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any, List, Tuple
+
+from ._version import version
+from opentrons.config import (
+    IS_ROBOT,
+    ROBOT_FIRMWARE_DIR,
+    name,
+    robot_configs,
+)
+from opentrons.config import (
+    feature_flags as ff,
+)
+from opentrons.drivers.serial_communication import get_ports_by_name
+from opentrons.hardware_control import (
+    API as HardwareAPI,
+)
+from opentrons.hardware_control import (
+    ThreadManagedHardware,
+    ThreadManager,
+)
+from opentrons.hardware_control import (
+    types as hw_types,
+)
+from opentrons.protocols.api_support.types import APIVersion
+from opentrons.protocols.types import ApiDeprecationError
+from opentrons.util import logging_config
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+__version__ = version
+
+
+LEGACY_MODULES = ["robot", "reset", "instruments", "containers", "labware", "modules"]
+
+
+__all__ = ["version", "__version__", "HERE", "config"]
+
+
+def __getattr__(attrname: str) -> None:
+    """
+    Prevent import of legacy modules from global to officially
+    deprecate Python API Version 1.0.
+    """
+    if attrname in LEGACY_MODULES:
+        raise ApiDeprecationError(APIVersion(1, 0))
+    raise AttributeError(attrname)
+
+
+def __dir__() -> List[str]:
+    return sorted(__all__ + LEGACY_MODULES)
+
+
+log = logging.getLogger(__name__)
+
+
+SMOOTHIE_HEX_RE = re.compile("smoothie-(.*).hex")
+
+
+def _find_smoothie_file() -> Tuple[Path, str]:
+    resources: List[Path] = []
+
+    # Search for smoothie files in /usr/lib/firmware first then fall back to
+    # value packed in wheel
+    if IS_ROBOT:
+        resources.extend(ROBOT_FIRMWARE_DIR.iterdir())  # type: ignore
+
+    resources_path = Path(HERE) / "resources"
+    resources.extend(resources_path.iterdir())
+
+    for path in resources:
+        matches = SMOOTHIE_HEX_RE.search(path.name)
+        if matches:
+            branch_plus_ref = matches.group(1)
+            return path, branch_plus_ref
+    raise OSError(f"Could not find smoothie firmware file in {resources_path}")
+
+
+def _get_motor_control_serial_port() -> Any:
+    port = os.environ.get("OT_SMOOTHIE_EMULATOR_URI")
+
+    if port is None:
+        smoothie_id = os.environ.get("OT_SMOOTHIE_ID", "AMA")
+        # TODO(mc, 2021-08-01): raise a more informative exception than
+        # IndexError if a valid serial port is not found
+        port = get_ports_by_name(device_name=smoothie_id)[0]
+
+    log.info(f"Connecting to motor controller at port {port}")
+    return port
+
+
+def should_use_ot3() -> bool:
+    """Return true if ot3 hardware controller should be used."""
+    if ff.enable_ot3_hardware_controller():
+        try:
+            from opentrons_hardware.drivers.can_bus import CanDriver  # noqa: F401
+
+            return True
+        except ModuleNotFoundError:
+            log.exception("Cannot use OT3 Hardware controller.")
+    return False
+
+
+async def _create_thread_manager() -> ThreadManagedHardware:
+    """Build the hardware controller wrapped in a ThreadManager.
+
+    .. deprecated:: 4.6
+        ThreadManager is on its way out.
+    """
+    if os.environ.get("ENABLE_VIRTUAL_SMOOTHIE"):
+        log.info("Initialized robot using virtual Smoothie")
+        thread_manager: ThreadManagedHardware = ThreadManager(
+            HardwareAPI.build_hardware_simulator
+        )
+    elif should_use_ot3():
+        from opentrons.hardware_control.ot3api import OT3API
+
+        thread_manager = ThreadManager(
+            ThreadManager.nonblocking_builder(OT3API.build_hardware_controller),
+            use_usb_bus=ff.rear_panel_integration(),
+            status_bar_enabled=ff.status_bar_enabled(),
+            feature_flags=hw_types.HardwareFeatureFlags.build_from_ff(),
+        )
+    else:
+        thread_manager = ThreadManager(
+            ThreadManager.nonblocking_builder(HardwareAPI.build_hardware_controller),
+            port=_get_motor_control_serial_port(),
+            firmware=_find_smoothie_file(),
+            feature_flags=hw_types.HardwareFeatureFlags.build_from_ff(),
+        )
+
+    try:
+        await thread_manager.managed_thread_ready_async()
+    except RuntimeError:
+        log.exception("Could not build hardware controller, forcing virtual")
+        thread_manager = ThreadManager(HardwareAPI.build_hardware_simulator)
+
+    return thread_manager
+
+
+async def initialize() -> ThreadManagedHardware:
+    """
+    Initialize the Opentrons hardware returning a hardware instance.
+    """
+    robot_conf = robot_configs.load()
+    logging_config.log_init(robot_conf.log_level)
+
+    log.info(f"API server version: {version}")
+    log.info(f"Robot Name: {name()}")
+
+    return await _create_thread_manager()

opentrons-9.0.0a0/src/opentrons/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '9.0.0a0'
+__version_tuple__ = version_tuple = (9, 0, 0, 'a0')
+
+__commit_id__ = commit_id = None

opentrons-9.0.0a0/src/opentrons/calibration_storage/__init__.py

@@ -0,0 +1,52 @@
+from . import helpers, ot2, ot3
+from .deck_configuration import (
+    deserialize_deck_configuration,
+    serialize_deck_configuration,
+)
+from .ot2 import mark_bad_calibration
+from .ot2.deck_attitude import (
+    delete_robot_deck_attitude,
+    get_robot_deck_attitude,
+    save_robot_deck_attitude,
+)
+from .ot2.pipette_offset import get_all_pipette_offset_calibrations
+
+# TODO these functions are only used in robot server. We should think about moving them and/or
+# abstracting it away from a robot specific function. We should also check if the tip rack
+# definition information is still needed.
+from .ot2.tip_length import (
+    _save_custom_tiprack_definition,
+    get_all_tip_length_calibrations,
+    get_custom_tiprack_definition_for_tlc,
+)
+from .ot3 import gripper_offset
+from .ot3.deck_attitude import (
+    delete_robot_belt_attitude,
+    get_robot_belt_attitude,
+    save_robot_belt_attitude,
+)
+
+__all__ = [
+    "helpers",
+    # deck calibration functions
+    "save_robot_deck_attitude",
+    "get_robot_deck_attitude",
+    "delete_robot_deck_attitude",
+    "save_robot_belt_attitude",
+    "get_robot_belt_attitude",
+    "delete_robot_belt_attitude",
+    # deck configuration functions
+    "serialize_deck_configuration",
+    "deserialize_deck_configuration",
+    # functions only used in robot server
+    "_save_custom_tiprack_definition",
+    "get_custom_tiprack_definition_for_tlc",
+    "get_all_pipette_offset_calibrations",
+    "get_all_tip_length_calibrations",
+    # file exports
+    "gripper_offset",
+    "mark_bad_calibration",
+    # Platform specific submodules
+    "ot2",
+    "ot3",
+]

opentrons-9.0.0a0/src/opentrons/calibration_storage/deck_configuration.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+import pydantic
+
+from . import file_operators as io
+from .types import CutoutFixturePlacement
+
+
+class _CutoutFixturePlacementModel(pydantic.BaseModel):
+    cutoutId: str
+    cutoutFixtureId: str
+    opentronsModuleSerialNumber: Optional[str] = None
+
+
+class _DeckConfigurationModel(pydantic.BaseModel):
+    """The on-filesystem representation of a deck configuration."""
+
+    cutoutFixtures: List[_CutoutFixturePlacementModel]
+    lastModified: datetime
+
+
+def serialize_deck_configuration(
+    cutout_fixture_placements: List[CutoutFixturePlacement], last_modified: datetime
+) -> bytes:
+    """Serialize a deck configuration for storing on the filesystem."""
+    data = _DeckConfigurationModel.model_construct(
+        cutoutFixtures=[
+            _CutoutFixturePlacementModel.model_construct(
+                cutoutId=e.cutout_id,
+                cutoutFixtureId=e.cutout_fixture_id,
+                opentronsModuleSerialNumber=e.opentrons_module_serial_number,
+            )
+            for e in cutout_fixture_placements
+        ],
+        lastModified=last_modified,
+    )
+    return io.serialize_pydantic_model(data)
+
+
+# TODO(mm, 2023-11-21): If the data is corrupt, we should propagate the underlying error.
+# And there should be an enumerated "corrupt storage" error in shared-data.
+def deserialize_deck_configuration(
+    serialized: bytes,
+) -> Optional[Tuple[List[CutoutFixturePlacement], datetime]]:
+    """Deserialize bytes previously serialized by `serialize_deck_configuration()`.
+
+    Returns a tuple `(deck_configuration, last_modified_time)`, or `None` if the data is corrupt.
+    """
+    parsed = io.deserialize_pydantic_model(serialized, _DeckConfigurationModel)
+    if parsed is None:
+        return None
+    else:
+        cutout_fixture_placements = [
+            CutoutFixturePlacement(
+                cutout_id=e.cutoutId,
+                cutout_fixture_id=e.cutoutFixtureId,
+                opentrons_module_serial_number=e.opentronsModuleSerialNumber,
+            )
+            for e in parsed.cutoutFixtures
+        ]
+        return cutout_fixture_placements, parsed.lastModified

opentrons-9.0.0a0/src/opentrons/calibration_storage/encoder_decoder.py

@@ -0,0 +1,32 @@
+"""opentrons.calibration_storage.encoder_decoder: classes that
+allow you to customize serialization to/from json.
+"""
+
+import datetime
+import json
+from typing import Any, cast
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    def default(self, obj: object) -> Any:
+        if isinstance(obj, datetime.datetime):
+            return obj.isoformat()
+        return json.JSONEncoder.default(self, obj)
+
+
+class DateTimeDecoder(json.JSONDecoder):
+    def __init__(self) -> None:
+        super().__init__(object_hook=self.dict_to_obj)
+
+    def dict_to_obj(self, d: object) -> Any:
+        if isinstance(d, dict):
+            d = {k: self._decode_datetime(v) for k, v in d.items()}
+        return d
+
+    def _decode_datetime(self, obj: object) -> Any:
+        try:
+            return datetime.datetime.fromisoformat(cast(str, obj))
+        except ValueError:
+            return obj
+        except TypeError:
+            return self.dict_to_obj(obj)