-
-
+
+This standard is similar to the [Opentrons API labware naming standard](https://ecatalog.corning.com/life-sciences/b2b/UK/en/Microplates/Assay-Microplates/96-Well-Microplates/Costar%C2%AE-Multiple-Well-Cell-Culture-Plates/p/3516) but 1) further sub-categorizes "wellplates" to facilitate communication with day-to-day users, and 2) adds information about the well-bottom geometry.
+
+```{toctree}
+:caption: Library
+
+library/alpaqua
+library/azenta
+library/boekel
+library/celltreat
+library/corning_axygen
+library/corning_costar
+library/eppendorf
+library/falcon
+library/ml_star
+library/opentrons
+library/porvair
+library/revvity
+library/thermo_fisher
+```
diff --git a/docs/resources/introduction.md b/docs/resources/introduction.md
index 690a12fb26..fe90ca13ca 100644
--- a/docs/resources/introduction.md
+++ b/docs/resources/introduction.md
@@ -2,17 +2,17 @@
This document introduces PyLabRobot Resources (labware and deck definitions) and general subclasses. You can find more information on creating custom resources in the {doc}`custom-resources` section.
-In PyLabRobot, a {class}`pylabrobot.resources.Resource` is a piece of labware or equipment used in a protocol or program, a part of a labware item (such as a Well) or a container of labware items (such as a Deck). All resources inherit from a single base class {class}`pylabrobot.resources.Resource` that provides most of the functionality, such as the name, sizing, type, model, as well as methods for dealing with state. The name and sizing are required for all resources, with the name being a unique identifier for the resource and the sizing being the x, y and z-dimensions of the resource in millimeters when conceptualized as a cuboid.
+In PyLabRobot, a {class}`pylabrobot.resources.resource.Resource` is a piece of labware or equipment used in a protocol or program, a part of a labware item (such as a Well) or a container of labware items (such as a Deck). All resources inherit from a single base class {class}`pylabrobot.resources.resource.Resource` that provides most of the functionality, such as the name, sizing, type, model, as well as methods for dealing with state. The name and sizing are required for all resources, with the name being a unique identifier for the resource and the sizing being the x, y and z-dimensions of the resource in millimeters when conceptualized as a cuboid.
-While you can instantiate a `Resource` directly, several subclasses of methods exist to provide additional functionality and model specific resource attributes. For example, a {class}`pylabrobot.resources.plate.Plate` has methods for easily accessing {class}`pylabrobot.resources.Well`s.
+While you can instantiate a `Resource` directly, several subclasses of methods exist to provide additional functionality and model specific resource attributes. For example, a {class}`pylabrobot.resources.plate.Plate` has methods for easily accessing {class}`pylabrobot.resources.well.Well`s.
-The relation between resources is modelled by a tree, specifically an [_arborescence_](
| `Azenta4titudeFrameStar_96_wellplate_skirted` |
+| 'Azenta4titudeFrameStar_96_wellplate_skirted'
| `boekel_50mL_falcon_carrier` |
-| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) | 
| `boekel_15mL_falcon_carrier` |
-| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) | 
| `boekel_1_5mL_microcentrifuge_carrier` |
-| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) | 
| `boekel_mini_microcentrifuge_carrier` |
+| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) |  | `boekel_50mL_falcon_carrier` |
+| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) |  | `boekel_15mL_falcon_carrier` |
+| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) |  | `boekel_1_5mL_microcentrifuge_carrier` |
+| Multi Tube Rack For 50ml Conical, 15ml Conical, And Microcentrifuge Tubes, PN:120008 [manufacturer website](https://www.boekelsci.com/multi-tube-rack-for-50ml-conical-15ml-conical-and-microcentrifuge-tubes-pn-120008.html) |  | `boekel_mini_microcentrifuge_carrier` |
diff --git a/docs/resources/library/celltreat.md b/docs/resources/library/celltreat.md
new file mode 100644
index 0000000000..23a437fc93
--- /dev/null
+++ b/docs/resources/library/celltreat.md
@@ -0,0 +1,8 @@
+# CellTreat
+
+## Plats
+
+| Description | Image | PLR definition |
+|-|-|-|
+| 'CellTreat_6_DWP_16300ul_Fb'
| `Axy_24_DW_10ML` |
+| Description | Image | PLR definition |
+|-|-|-|
+| 'Axy_24_DW_10ML'
| `Porvair_6x47_Reservoir` |
+| 'Porvair_6_reservoir_47ml_Vb'
| `Revvity_ProxiPlate_384Plus`
+| 'Revvity_ProxiPlate_384Plus'
| `falcon_tube_50mL`
-| 15mL Falcon Tube [manufacturer website](https://www.fishersci.com/shop/products/falcon-15ml-conical-centrifuge-tubes-5/p-193301) | 
| `falcon_tube_15mL`
diff --git a/pylabrobot/resources/falcon/plates.py b/pylabrobot/resources/falcon/plates.py
new file mode 100644
index 0000000000..a377c189a0
--- /dev/null
+++ b/pylabrobot/resources/falcon/plates.py
@@ -0,0 +1,127 @@
+
+from typing import Optional
+
+from pylabrobot.resources.height_volume_functions import (
+ compute_height_from_volume_conical_frustum,
+ compute_volume_from_height_conical_frustum)
+from pylabrobot.resources.plate import Lid, Plate
+from pylabrobot.resources.utils import create_ordered_items_2d
+from pylabrobot.resources.well import CrossSectionType, Well, WellBottomType
+
+
+def Falcon_96_wellplate_Fl(name: str, lid: Optional[Lid] = None) -> Plate:
+ """
+ Falcon cat. no.: 353072
+ - Material: Polystyrene
+ """
+ BOTTOM_RADIUS = 3.175
+ TOP_RADIUS = 3.425
+
+ return Plate(
+ name=name,
+ size_x=127.76, # directly from reference manual
+ size_y=85.11, # directly from reference manual
+ size_z=14.30, # without lid, directly from reference manual
+ lid=lid,
+ model=Falcon_96_wellplate_Fl.__name__,
+ ordered_items=create_ordered_items_2d(
+ Well,
+ num_items_x=12,
+ num_items_y=8,
+ dx=11.05, # measured
+ dy=7.75, # measured
+ dz=1.11, # from reference manual
+ item_dx=8.99,
+ item_dy=8.99,
+ size_x=6.35,
+ size_y=6.35,
+ size_z=14.30,
+ bottom_type=WellBottomType.FLAT,
+ compute_volume_from_height=lambda liquid_height: compute_volume_from_height_conical_frustum(
+ liquid_height, BOTTOM_RADIUS, TOP_RADIUS
+ ),
+ compute_height_from_volume=lambda liquid_volume: compute_height_from_volume_conical_frustum(
+ liquid_volume, BOTTOM_RADIUS, TOP_RADIUS
+ ),
+ ),
+ )
+
+def Falcon_96_wellplate_Rb(name: str, lid: Optional[Lid] = None) -> Plate:
+ """
+ Falcon cat. no.: 353077
+ - Material: Polystyrene
+ - Tissue culture treated: Yes
+ spec: https://www.corning.com/catalog/cls/documents/drawings/LSR00181.pdf
+ """
+ TOP_INNER_WELL_RADIUS = 3.425
+ BOTTOM_INNER_WELL_RADIUS = 3.175
+
+ well_kwargs = {
+ "size_x": BOTTOM_INNER_WELL_RADIUS * 2,
+ "size_y": BOTTOM_INNER_WELL_RADIUS * 2,
+ "size_z": 14.30, # from spec
+ "bottom_type": WellBottomType.U,
+ "max_volume": 0.25, # from spec
+ }
+
+ return Plate(
+ name=name,
+ size_x=127.76,
+ size_y=85.11,
+ size_z=14.30,
+ lid=lid,
+ model=Falcon_96_wellplate_Rb.__name__,
+ ordered_items=create_ordered_items_2d(
+ Well,
+ num_items_x=12,
+ num_items_y=8,
+ dx=14.38 - TOP_INNER_WELL_RADIUS, # from spec
+ dy=11.39 - TOP_INNER_WELL_RADIUS, # from spec
+ dz=1.80, # calibrated manually by z-stepping down using a pipette.
+ item_dx=8.99, # measured
+ item_dy=8.99, # measured
+ **well_kwargs,
+ ),
+ )
+
+def Falcon_96_wellplate_Fl_Black(name: str, lid: Optional[Lid] = None) -> Plate:
+ """
+ Falcon Catalog No. 353219
+ """
+ TOP_INNER_WELL_RADIUS = 6.96 / 2 # from spec
+ BOTTOM_INNER_WELL_RADIUS = 6.58 / 2 # from spec
+
+ well_kwargs = {
+ "size_x": TOP_INNER_WELL_RADIUS * 2, # from spec
+ "size_y": TOP_INNER_WELL_RADIUS * 2, # from spec
+ "size_z": 10.90, # from spec
+ "bottom_type": WellBottomType.FLAT,
+ "cross_section_type": CrossSectionType.CIRCLE,
+ "compute_volume_from_height": lambda liquid_height: compute_volume_from_height_conical_frustum(
+ liquid_height, BOTTOM_INNER_WELL_RADIUS, TOP_INNER_WELL_RADIUS
+ ),
+ "compute_height_from_volume": lambda liquid_volume: compute_height_from_volume_conical_frustum(
+ liquid_volume, BOTTOM_INNER_WELL_RADIUS, TOP_INNER_WELL_RADIUS
+ ),
+ "material_z_thickness": 0.15, # measured at 0.15 mm
+ }
+
+ return Plate(
+ name=name,
+ size_x=127.76, # from spec
+ size_y=85.48, # from spec
+ size_z=14.40, # from spec
+ lid=lid,
+ model=Falcon_96_wellplate_Fl_Black.__name__,
+ ordered_items=create_ordered_items_2d(
+ Well,
+ num_items_x=12,
+ num_items_y=8,
+ dx=10.7, # calculated from spec, manually calibrated
+ dy=7.7, # calculated from spec, manually calibrated
+ dz=6.7, # calculated from spec, manually calibrated
+ item_dx=9,
+ item_dy=9,
+ **well_kwargs,
+ ),
+ )
diff --git a/pylabrobot/resources/falcon/tubes.py b/pylabrobot/resources/falcon/tubes.py
index 18c64cce86..6c6a17c596 100644
--- a/pylabrobot/resources/falcon/tubes.py
+++ b/pylabrobot/resources/falcon/tubes.py
@@ -14,7 +14,8 @@ def falcon_tube_50mL(name: str) -> Tube: # pylint: disable=invalid-name
size_y=diameter,
size_z=115,
model="Falcon 50mL",
- max_volume=50_000
+ max_volume=50_000,
+ material_z_thickness=1.2
)
@@ -33,3 +34,22 @@ def falcon_tube_15mL(name: str) -> Tube: # pylint: disable=invalid-name
model="Falcon 15mL",
max_volume=15_000
)
+
+
+def Falcon_tube_14mL_Rb(name: str) -> Tube:
+ """ 14 mL round-bottom snap-cap Falcon tube. Corning cat. no.: 352059
+
+ - Material: polypropylene
+ - bottom_type=TubeBottomType.U
+ - snap-cap lid
+ """
+ # material_z_thickness = 1.2 mm
+ diameter = 17
+ return Tube(
+ name=name,
+ size_x=diameter,
+ size_y=diameter,
+ size_z=95,
+ model="Falcon_tube_14mL_Rb",
+ max_volume=14_000 # units: ul
+ )
diff --git a/pylabrobot/resources/functional.py b/pylabrobot/resources/functional.py
new file mode 100644
index 0000000000..0e0d4d9703
--- /dev/null
+++ b/pylabrobot/resources/functional.py
@@ -0,0 +1,72 @@
+import json
+import logging
+import os
+import random
+from collections import deque
+from typing import AsyncGenerator, Deque, List, Optional
+from pylabrobot.resources.tip_rack import TipRack, TipSpot
+
+
+logger = logging.getLogger("pylabrobot.resources")
+
+
+def get_all_tip_spots(tip_racks: List[TipRack]) -> List[TipSpot]:
+ return [spot for rack in tip_racks for spot in rack.get_all_items()]
+
+
+async def linear_tip_spot_generator(
+ tip_spots: List[TipSpot],
+ cache_file_path: Optional[str]=None,
+ repeat: bool=False
+) -> AsyncGenerator[TipSpot, None]:
+ """ Tip spot generator with disk caching. Linearly iterate through all tip spots and
+ raise StopIteration when all spots have been used. """
+ tip_spot_idx = 0
+ if cache_file_path is not None and os.path.exists(cache_file_path):
+ with open(cache_file_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+ tip_spot_idx = data["tip_spot_idx"]
+ logger.info("loaded tip idx from disk: %s", data)
+
+ while True:
+ if cache_file_path is not None:
+ with open(cache_file_path, "w", encoding="utf-8") as f:
+ json.dump({"tip_spot_idx": tip_spot_idx}, f)
+ yield tip_spots[tip_spot_idx]
+ tip_spot_idx += 1
+ if tip_spot_idx >= len(tip_spots):
+ if repeat:
+ tip_spot_idx = 0
+ else:
+ return
+
+
+async def randomized_tip_spot_generator(
+ tip_spots: List[TipSpot],
+ K: int, cache_file_path: Optional[str]=None
+) -> AsyncGenerator[TipSpot, None]:
+ """ Randomized tip spot generator with disk caching. Don't return tip spots that have been
+ sampled in the last K samples. """
+
+ recently_sampled: Deque[str] = deque(maxlen=K)
+
+ if cache_file_path is not None and os.path.exists(cache_file_path):
+ with open(cache_file_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+ recently_sampled = deque(data["recently_sampled"], maxlen=K)
+ logger.info("loaded recently sampled tip spots from disk: %s", recently_sampled)
+
+ while True:
+ available_tips = [ts for ts in tip_spots if ts.name not in recently_sampled]
+
+ if not available_tips:
+ raise RuntimeError("All tips have been used recently, resetting list.")
+
+ chosen_tip_spot = random.choice(available_tips)
+ recently_sampled.append(chosen_tip_spot.name)
+
+ if cache_file_path is not None:
+ with open(cache_file_path, "w", encoding="utf-8") as f:
+ json.dump({"recently_sampled": list(recently_sampled)}, f)
+
+ yield chosen_tip_spot
diff --git a/pylabrobot/resources/greiner/plates.py b/pylabrobot/resources/greiner/plates.py
index 1ee8eb578f..a5791873ec 100644
--- a/pylabrobot/resources/greiner/plates.py
+++ b/pylabrobot/resources/greiner/plates.py
@@ -2,9 +2,9 @@
# pylint: disable=invalid-name
-from pylabrobot.resources.plate import Plate
+from pylabrobot.resources.plate import Lid, Plate
from pylabrobot.resources.well import Well, WellBottomType
-from pylabrobot.resources.itemized_resource import create_equally_spaced
+from pylabrobot.resources.utils import create_ordered_items_2d
def _compute_volume_from_height_Gre_384_Sq(h: float) -> float:
@@ -14,6 +14,19 @@ def _compute_volume_from_height_Gre_384_Sq(h: float) -> float:
return volume
+def Gre_384_Sq_Lid(name: str) -> Lid:
+ raise NotImplementedError("This lid is not currently defined.")
+ # See https://github.com/PyLabRobot/pylabrobot/pull/161.
+ # return Lid(
+ # name=name,
+ # size_x=127.0,
+ # size_y=86.0,
+ # size_z=None, # measure the total z height
+ # nesting_z_height=None, # measure overlap between lid and plate
+ # model="Gre_384_Sq_Lid",
+ # )
+
+
def Gre_384_Sq(name: str, with_lid: bool = False) -> Plate:
""" Gre_384_Sq """
return Plate(
@@ -21,14 +34,14 @@ def Gre_384_Sq(name: str, with_lid: bool = False) -> Plate:
size_x=127.0,
size_y=86.0,
size_z=14.5,
- with_lid=with_lid,
+ lid=Gre_384_Sq_Lid(name + "_lid") if with_lid else None,
model="Gre_384_Sq",
- items=create_equally_spaced(Well,
+ ordered_items=create_ordered_items_2d(Well,
num_items_x=24,
num_items_y=16,
- dx=9.5,
# dy=-1215.5, # from hamilton definition
- dy=12.155, # verified empirically
+ dx=7 + 2.25, # (86 - 16*4.5) / 2 + half well width
+ dy=9.5 + 2.25, # (86 - 16*4.5) / 2 + half well width
dz=2.85,
item_dx=4.5,
item_dy=4.5,
@@ -48,6 +61,19 @@ def _compute_volume_from_height_Gre_1536_Sq(h: float) -> float:
return volume
+def Gre_1536_Sq_Lid(name: str) -> Lid:
+ raise NotImplementedError("This lid is not currently defined.")
+ # See https://github.com/PyLabRobot/pylabrobot/pull/161.
+ # return Lid(
+ # name=name,
+ # size_x=127.0,
+ # size_y=86.0,
+ # size_z=None, # measure the total z height
+ # nesting_z_height=None, # measure overlap between lid and plate
+ # model="Gre_1536_Sq_Lid",
+ # )
+
+
def Gre_1536_Sq(name: str, with_lid: bool = False) -> Plate:
""" Gre_1536_Sq """
return Plate(
@@ -55,9 +81,9 @@ def Gre_1536_Sq(name: str, with_lid: bool = False) -> Plate:
size_x=127.0,
size_y=86.0,
size_z=10.4,
- with_lid=with_lid,
+ lid=Gre_1536_Sq_Lid(name + "_lid") if with_lid else None,
model="Gre_1536_Sq",
- items=create_equally_spaced(Well,
+ ordered_items=create_ordered_items_2d(Well,
num_items_x=48,
num_items_y=32,
dx=9.5,
@@ -82,7 +108,7 @@ def Gre_1536_Sq_L(name: str, with_lid: bool = False) -> Plate:
def Gre_1536_Sq_P(name: str, with_lid: bool = False) -> Plate:
""" Gre_1536_Sq """
- return Gre_1536_Sq(name=name, with_lid=with_lid).rotated(90)
+ return Gre_1536_Sq(name=name, with_lid=with_lid).rotated(z=90)
def _compute_volume_from_height_Greiner96Well_655_101(h: float) -> float:
volume = min(h, 10.9)*35.0152
if h > 10.9:
@@ -90,6 +116,19 @@ def _compute_volume_from_height_Greiner96Well_655_101(h: float) -> float:
return volume
+def Greiner96Well_655_101_Lid(name: str) -> Lid:
+ raise NotImplementedError("This lid is not currently defined.")
+ # See https://github.com/PyLabRobot/pylabrobot/pull/161.
+ # return Lid(
+ # name=name,
+ # size_x=127.0,
+ # size_y=86.0,
+ # size_z=None, # measure the total z height
+ # nesting_z_height=None, # measure overlap between lid and plate
+ # model="Greiner96Well_655_101_Lid",
+ # )
+
+
# done with python
# plate, description, eqn = create_plate_for_writing(path, ctr_filepath=ctr_path)
# ctr_path = 'Well655_101.ctr'
@@ -101,9 +140,9 @@ def Greiner96Well_655_101(name: str, with_lid: bool = False) -> Plate:
size_x=127.0,
size_y=86.0,
size_z=14.4,
- with_lid=with_lid,
+ lid=Greiner96Well_655_101_Lid(name + "_lid") if with_lid else None,
model="Greiner96Well_655_101",
- items=create_equally_spaced(Well,
+ ordered_items=create_ordered_items_2d(Well,
num_items_x=12,
num_items_y=8,
dx=9.5,
@@ -129,6 +168,19 @@ def _compute_volume_from_height_Greiner96Well_650_201_RB(h: float) -> float:
return volume
+def Greiner96Well_650_201_RB_Lid(name: str) -> Lid:
+ raise NotImplementedError("This lid is not currently defined.")
+ # See https://github.com/PyLabRobot/pylabrobot/pull/161.
+ # return Lid(
+ # name=name,
+ # size_x=127.0,
+ # size_y=86.0,
+ # size_z=None, # measure the total z height
+ # nesting_z_height=None, # measure overlap between lid and plate
+ # model="Greiner96Well_650_201_RB_Lid",
+ # )
+
+
def Greiner96Well_650_201_RB(name: str, with_lid: bool = False) -> Plate:
""" Greiner96Well_650_201_RB """
return Plate(
@@ -136,9 +188,9 @@ def Greiner96Well_650_201_RB(name: str, with_lid: bool = False) -> Plate:
size_x=127.0,
size_y=86.0,
size_z=14.6,
- with_lid=with_lid,
+ lid=Greiner96Well_650_201_RB_Lid(name + "_lid") if with_lid else None,
model="Greiner96Well_650_201_RB",
- items=create_equally_spaced(Well,
+ ordered_items=create_ordered_items_2d(Well,
num_items_x=12,
num_items_y=8,
dx=9.88,
diff --git a/pylabrobot/resources/hamilton/hamilton_deck_tests.py b/pylabrobot/resources/hamilton/hamilton_deck_tests.py
index e7f6d7ec5b..1281d36966 100644
--- a/pylabrobot/resources/hamilton/hamilton_deck_tests.py
+++ b/pylabrobot/resources/hamilton/hamilton_deck_tests.py
@@ -1,81 +1,15 @@
import textwrap
-from typing import cast
import unittest
-from pylabrobot.resources.coordinate import Coordinate
-from pylabrobot.resources.itemized_resource import ItemizedResource
-from pylabrobot.resources.carrier import TipCarrier, PlateCarrier
-from pylabrobot.resources.corning_costar import Cos_96_DW_1mL, Cos_96_DW_500ul
-from pylabrobot.resources.hamilton import HamiltonSTARDeck, STARLetDeck
+from pylabrobot.resources.corning_costar import Cor_96_wellplate_360ul_Fb
+from pylabrobot.resources.stanley.cups import StanleyCup_QUENCHER_FLOWSTATE_TUMBLER
+from pylabrobot.resources.hamilton import STARLetDeck
from pylabrobot.resources.ml_star import STF_L, HTF_L, TIP_CAR_480_A00, PLT_CAR_L5AC_A00
-from pylabrobot.resources.resource import Resource
class HamiltonDeckTests(unittest.TestCase):
""" Tests for the HamiltonDeck class. """
- def test_parse_lay_file(self):
- fn = "./pylabrobot/testing/test_data/test_deck.lay"
- deck = HamiltonSTARDeck.load_from_lay_file(fn)
-
- tip_car = deck.get_resource("TIP_CAR_480_A00_0001")
- assert isinstance(tip_car, TipCarrier)
-
- def get_item_center(name: str) -> Coordinate:
- tip_rack = cast(ItemizedResource, deck.get_resource(name))
- tip = cast(Resource, tip_rack.get_item("A1"))
- return tip.get_absolute_location() + tip.center()
-
- self.assertEqual(tip_car.get_absolute_location(), Coordinate(122.500, 63.000, 100.000))
- self.assertEqual(get_item_center("tips_01"), Coordinate(140.400, 145.800, 164.450))
- self.assertEqual(get_item_center("STF_L_0001"), Coordinate(140.400, 241.800, 164.450))
- self.assertEqual(get_item_center("tips_04"), Coordinate(140.400, 433.800, 131.450))
-
- assert tip_car[0].resource is not None
- self.assertEqual(tip_car[0].resource.name, "tips_01")
- assert tip_car[1].resource is not None
- self.assertEqual(tip_car[1].resource.name, "STF_L_0001")
- self.assertIsNone(tip_car[2].resource)
- assert tip_car[3].resource is not None
- self.assertEqual(tip_car[3].resource.name, "tips_04")
- self.assertIsNone(tip_car[4].resource)
-
- self.assertEqual(deck.get_resource("PLT_CAR_L5AC_A00_0001").get_absolute_location(),
- Coordinate(302.500, 63.000, 100.000))
- self.assertEqual(get_item_center("Cos_96_DW_1mL_0001"), Coordinate(320.500, 146.000, 187.150))
- self.assertEqual(get_item_center("Cos_96_DW_500ul_0001"), Coordinate(320.500, 338.000, 188.150))
- self.assertEqual(get_item_center("Cos_96_DW_1mL_0002"), Coordinate(320.500, 434.000, 187.150))
- self.assertEqual(get_item_center("Cos_96_DW_2mL_0001"), Coordinate(320.500, 530.000, 187.150))
-
- plt_car1 = deck.get_resource("PLT_CAR_L5AC_A00_0001")
- assert isinstance(plt_car1, PlateCarrier)
- assert plt_car1[0].resource is not None
- self.assertEqual(plt_car1[0].resource.name, "Cos_96_DW_1mL_0001")
- self.assertIsNone(plt_car1[1].resource)
- assert plt_car1[2].resource is not None
- self.assertEqual(plt_car1[2].resource.name, "Cos_96_DW_500ul_0001")
- assert plt_car1[3].resource is not None
- self.assertEqual(plt_car1[3].resource.name, "Cos_96_DW_1mL_0002")
- assert plt_car1[4].resource is not None
- self.assertEqual(plt_car1[4].resource.name, "Cos_96_DW_2mL_0001")
-
- self.assertEqual(deck.get_resource("PLT_CAR_L5AC_A00_0002").get_absolute_location(),
- Coordinate(482.500, 63.000, 100.000))
- self.assertEqual(get_item_center("Cos_96_DW_1mL_0003"), Coordinate(500.500, 146.000, 187.150))
- self.assertEqual(get_item_center("Cos_96_DW_500ul_0003"), Coordinate(500.500, 242.000, 188.150))
- self.assertEqual(get_item_center("Cos_96_PCR_0001"), Coordinate(500.500, 434.000, 186.650))
-
- plt_car2 = deck.get_resource("PLT_CAR_L5AC_A00_0002")
- assert isinstance(plt_car2, PlateCarrier)
- assert plt_car2[0].resource is not None
- self.assertEqual(plt_car2[0].resource.name, "Cos_96_DW_1mL_0003")
- assert plt_car2[1].resource is not None
- self.assertEqual(plt_car2[1].resource.name, "Cos_96_DW_500ul_0003")
- self.assertIsNone(plt_car2[2].resource)
- assert plt_car2[3].resource is not None
- self.assertEqual(plt_car2[3].resource.name, "Cos_96_PCR_0001")
- self.assertIsNone(plt_car2[4].resource)
-
def build_layout(self):
""" Build a deck layout for testing """
deck = STARLetDeck()
@@ -86,8 +20,8 @@ def build_layout(self):
tip_car[3] = HTF_L(name="tip_rack_04")
plt_car = PLT_CAR_L5AC_A00(name="plate carrier")
- plt_car[0] = Cos_96_DW_1mL(name="aspiration plate")
- plt_car[2] = Cos_96_DW_500ul(name="dispense plate")
+ plt_car[0] = Cor_96_wellplate_360ul_Fb(name="aspiration plate")
+ plt_car[2] = Cor_96_wellplate_360ul_Fb(name="dispense plate")
deck.assign_child_resource(tip_car, rails=1)
deck.assign_child_resource(plt_car, rails=21)
@@ -98,23 +32,34 @@ def test_summary(self):
self.maxDiff = None
deck = self.build_layout()
self.assertEqual(deck.summary(), textwrap.dedent("""
- Rail Resource Type Coordinates (mm)
- ==============================================================================================
- (-13) ├── trash_core96 Trash (-232.100, 110.300, 189.000)
+ Rail Resource Type Coordinates (mm)
+ =================================================================================
+ (-13) ├── trash_core96 Trash (-232.100, 110.300, 189.000)
│
- (1) ├── tip_carrier TipCarrier (100.000, 063.000, 100.000)
- │ ├── tip_rack_01 TipRack (117.900, 145.800, 164.450)
- │ ├── tip_rack_02 TipRack (117.900, 241.800, 164.450)
+ (1) ├── tip_carrier TipCarrier (100.000, 063.000, 100.000)
+ │ ├── tip_rack_01 TipRack (106.200, 073.000, 214.950)
+ │ ├── tip_rack_02 TipRack (106.200, 169.000, 214.950)
│ ├── 
| `TIP_CAR_480_A00` |
-
----
-
-### Currently defined plate carriers:
-
-| Description | Image | PLR definition |
-|--------------------|--------------------|--------------------|
-| 'PLT_CAR_L5AC_A00'
| `PLT_CAR_L5AC_A00` |
-
----
-
-### Currently defined MFX carriers:
-
-| Description | Image | PLR definition |
-|--------------------|--------------------|--------------------|
-| 'MFX_CAR_L5_base'
| `MFX_CAR_L5_base` |
-
-
-
-#### Currently defined MFX modules:
-
-| Description | Image | PLR definition |
-|--------------------|--------------------|--------------------|
-| 'MFX_TIP_module'
| `MFX_TIP_module` |
-| 'MFX_DWP_rackbased_module'
| `MFX_DWP_rackbased_module` |
diff --git a/pylabrobot/resources/ml_star/__init__.py b/pylabrobot/resources/ml_star/__init__.py
index 5a87c55c39..48371d6dc5 100644
--- a/pylabrobot/resources/ml_star/__init__.py
+++ b/pylabrobot/resources/ml_star/__init__.py
@@ -1,6 +1,14 @@
+from .plate_adapters import *
from .plate_carriers import *
-from .tip_carriers import *
+
from .mfx_carriers import *
-from .tip_racks import *
-from .tip_creators import *
from .mfx_modules import *
+
+from .tip_carriers import *
+from .tip_creators import *
+from .tip_racks import *
+
+from .trough_carriers import *
+from .troughs import *
+
+from .tube_carriers import *
diff --git a/pylabrobot/resources/ml_star/mfx_carriers.py b/pylabrobot/resources/ml_star/mfx_carriers.py
index fcd214bdd4..7bf81124e2 100644
--- a/pylabrobot/resources/ml_star/mfx_carriers.py
+++ b/pylabrobot/resources/ml_star/mfx_carriers.py
@@ -1,34 +1,59 @@
-""" ML Star MultiFleX (MFX) carriers """
-
-# pylint: disable=empty-docstring
-# pylint: disable=invalid-name
-# pylint: disable=line-too-long
-
-from pylabrobot.resources.carrier import (
- MFXCarrier,
- Coordinate,
- create_homogeneous_carrier_sites
-)
-
-
-def MFX_CAR_L5_base(name: str) -> MFXCarrier:
- """ Hamilton cat. no.: 188039
- Labware carrier base for up to 5 Multiflex Modules
- """
- return MFXCarrier(
- name=name,
- size_x=135.0,
- size_y=497.0,
- size_z=18.195,
- sites=create_homogeneous_carrier_sites([
- Coordinate(0.0, 5.0, 18.195),
- Coordinate(0.0, 101.0, 18.195),
- Coordinate(0.0, 197.0, 18.195),
- Coordinate(0.0, 293.0, 18.195),
- Coordinate(0.0, 389.0, 18.195)
- ],
- site_size_x=135.0,
- site_size_y=94.0,
- ),
- model="MFX_CAR_L5_base"
- )
+""" ML Star MultiFleX (MFX) carriers """
+
+# pylint: disable=empty-docstring
+# pylint: disable=invalid-name
+# pylint: disable=line-too-long
+
+from pylabrobot.resources.carrier import (
+ Coordinate,
+ CarrierSite,
+ MFXCarrier,
+ create_homogeneous_carrier_sites
+)
+
+
+def MFX_CAR_L5_base(name: str) -> MFXCarrier:
+ """ Hamilton cat. no.: 188039
+ Labware carrier base for up to 5 Multiflex Modules
+ """
+ return MFXCarrier(
+ name=name,
+ size_x=135.0,
+ size_y=497.0,
+ size_z=18.195,
+ sites=create_homogeneous_carrier_sites(klass=CarrierSite, locations=[
+ Coordinate(0.0, 5.0, 18.195),
+ Coordinate(0.0, 101.0, 18.195),
+ Coordinate(0.0, 197.0, 18.195),
+ Coordinate(0.0, 293.0, 18.195),
+ Coordinate(0.0, 389.0, 18.195)
+ ],
+ site_size_x=135.0,
+ site_size_y=94.0,
+ ),
+ model="MFX_CAR_L5_base"
+ )
+
+
+def MFX_CAR_L4_SHAKER(name: str) -> MFXCarrier:
+ """ Hamilton cat. no.: 187001
+ Sometimes referred to as "PLT_CAR_L4_SHAKER" by Hamilton.
+ Template carrier with 4 positions for Hamilton Heater Shaker.
+ Occupies 7 tracks (7T). Can be screwed onto the deck.
+ """
+ return MFXCarrier(
+ name=name,
+ size_x=157.5,
+ size_y=497.0,
+ size_z=8.0,
+ sites=create_homogeneous_carrier_sites(klass=CarrierSite, locations=[
+ Coordinate(6.0, 2, 8.0), # not tested, interpolated Coordinate
+ Coordinate(6.0, 123, 8.0), # not tested, interpolated Coordinate
+ Coordinate(6.0, 244.0, 8.0), # tested using Hamilton_HC
+ Coordinate(6.0, 365.0, 8.0), # tested using Hamilton_HS
+ ],
+ site_size_x=145.5,
+ site_size_y=104.0,
+ ),
+ model="PLT_CAR_L4_SHAKER"
+ )
diff --git a/pylabrobot/resources/ml_star/mfx_modules.py b/pylabrobot/resources/ml_star/mfx_modules.py
index bf2d66401a..8c0db9c123 100644
--- a/pylabrobot/resources/ml_star/mfx_modules.py
+++ b/pylabrobot/resources/ml_star/mfx_modules.py
@@ -19,23 +19,25 @@ class MFXModule(Resource):
Examples:
1. Creating MFX module for tips:
- Creating a `MFXCarrier`,
- Creating a `MFXModule` for tips,
- Assigning the `MFXModule` for tips to a carrier_site on the `MFXCarrier`,
- Creating and assigning a tip_rack to the MFXsite on the MFXModule:
+ Create a `MFXCarrier`,
+ Create `MFXModule` for tips,
+ Assign the `MFXModule` for tips to a carrier_site on the `MFXCarrier`,
+ Create and assign a tip_rack to the MFXModule:
>>> mfx_carrier_1 = MFX_CAR_L5_base(name='mfx_carrier_1')
>>> mfx_carrier_1[0] = mfx_tip_module_1 = MFX_TIP_module(name="mfx_tip_module_1")
- >>> mfx_tip_module_1[0] = tip_50ul_rack = TIP_50ul_L(name="tip_50ul_rack")
+ >>> tip_50ul_rack = TIP_50ul_L(name="tip_50ul_rack")
+ >>> mfx_tip_module_1.assign_child_resource(tip_50ul_rack)
2. Creating MFX module for plates:
Use the same `MFXCarrier` instance,
- Creating a `MFXModule` for plates,
- Assigning the `MFXModule` for plates to a carrier_site on the `MFXCarrier`,
- Creating and assigning a plate to the MFXsite on the MFXModule:
+ Create a `MFXModule` for plates,
+ Assign the `MFXModule` for plates to a carrier_site on the `MFXCarrier`,
+ Create and assign a plate directly to the MFXModule:
- >>> mfx_carrier_1[1] = mfx_dwp_module_1 = MFX_DWP_module(name="mfx_dwp_module_1")
- >>> mfx_dwp_module_1[0] = Cos96_plate_1 = Cos_96_Rd(name='Cos96_plate_1')
+ >>> mfx_carrier_1[1] = mfx_dwp_module_1 = MFX_DWP_rackbased_module(name="mfx_dwp_module_1")
+ >>> Cos96_plate_1 = Cos_96_Rd(name='cos96_plate_1')
+ >>> mfx_dwp_module_1.assign_child_resource(Cos96_plate_1)
"""
def __init__(
@@ -44,12 +46,15 @@ def __init__(
size_x: float, size_y: float, size_z: float,
child_resource_location: Coordinate,
category: Optional[str] = "mfx_module",
+ pedestal_size_z: Optional[float] = None,
model: Optional[str] = None):
super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z, category=category,
model=model)
# site where resources will be placed on this module
self._child_resource_location = child_resource_location
self._child_resource: Optional[Resource] = None
+ self.pedestal_size_z: Optional[float] = pedestal_size_z
+ # TODO: add self.pedestal_2D_offset if necessary in the future
@property
def child_resource_location(self) -> Coordinate:
@@ -63,6 +68,10 @@ def assign_child_resource(
):
""" Assign a resource to a site on this module. If `location` is not provided, the resource
will be placed at `self._child_resource_location` (wrt this module's left front bottom). """
+
+ # TODO: add conditional logic to modify Plate position based on whether
+ # pedestal_size_z>plate_true_dz OR pedestal_z
| `ThermoFisherMatrixTrough8094` |
diff --git a/pylabrobot/resources/thermo_fisher/__init__.py b/pylabrobot/resources/thermo_fisher/__init__.py
index ef151f9f3c..008b938ef8 100644
--- a/pylabrobot/resources/thermo_fisher/__init__.py
+++ b/pylabrobot/resources/thermo_fisher/__init__.py
@@ -1 +1,2 @@
+from .plates import *
from .troughs import *
diff --git a/pylabrobot/resources/thermo_fisher/plates.py b/pylabrobot/resources/thermo_fisher/plates.py
index 4b2214ffa4..b9fe07aa67 100644
--- a/pylabrobot/resources/thermo_fisher/plates.py
+++ b/pylabrobot/resources/thermo_fisher/plates.py
@@ -101,14 +101,14 @@ def Thermo_TS_96_wellplate_1200ul_Rb(name: str, with_lid: bool = False) -> Plate
num_items_y=8,
dx=10.0,
dy=7.3,
- dz=1.0, # 2.5. https://github.com/PyLabRobot/pylabrobot/pull/183
+ dz=2.5, # 2.5. https://github.com/PyLabRobot/pylabrobot/pull/183
item_dx=9,
item_dy=9,
size_x=8.3,
size_y=8.3,
size_z=20.5,
bottom_type=WellBottomType.U,
- material_z_thickness=1.0,
+ material_z_thickness=1.15,
cross_section_type=CrossSectionType.RECTANGLE,
compute_volume_from_height=(
_compute_volume_from_height_Thermo_TS_96_wellplate_1200ul_Rb
diff --git a/pylabrobot/resources/tip_rack.py b/pylabrobot/resources/tip_rack.py
index 7329c6433b..4faec75f60 100644
--- a/pylabrobot/resources/tip_rack.py
+++ b/pylabrobot/resources/tip_rack.py
@@ -1,10 +1,9 @@
-""" Abstract base class for tip rack resources. """
-
from __future__ import annotations
from abc import ABCMeta
from typing import Any, Dict, List, Union, Optional, Sequence, cast
+from pylabrobot.resources.coordinate import Coordinate
from pylabrobot.resources.tip import Tip, TipCreator
from pylabrobot.resources.tip_tracker import TipTracker, does_tip_tracking
from pylabrobot.serializer import deserialize
@@ -64,11 +63,11 @@ def serialize(self) -> dict:
}
@classmethod
- def deserialize(cls, data: dict) -> TipSpot:
+ def deserialize(cls, data: dict, allow_marshal: bool = False) -> TipSpot:
""" Deserialize a tip spot. """
tip_data = data["prototype_tip"]
def make_tip() -> Tip:
- return cast(Tip, deserialize(tip_data))
+ return cast(Tip, deserialize(tip_data, allow_marshal=allow_marshal))
return cls(
name=data["name"],
@@ -87,7 +86,7 @@ def load_state(self, state: Dict[str, Any]):
class TipRack(ItemizedResource[TipSpot], metaclass=ABCMeta):
- """ Abstract base class for Tips resources. """
+ """ Tip rack for disposable tips. """
def __init__(
self,
@@ -95,17 +94,16 @@ def __init__(
size_x: float,
size_y: float,
size_z: float,
- items: Optional[List[List[TipSpot]]] = None,
- num_items_x: Optional[int] = None,
- num_items_y: Optional[int] = None,
+ ordered_items: Optional[Dict[str, TipSpot]] = None,
+ ordering: Optional[List[str]] = None,
category: str = "tip_rack",
model: Optional[str] = None,
with_tips: bool = True,
):
- super().__init__(name, size_x, size_y, size_z, items=items, num_items_x=num_items_x,
- num_items_y=num_items_y, category=category, model=model)
+ super().__init__(name, size_x, size_y, size_z, ordered_items=ordered_items, ordering=ordering,
+ category=category, model=model)
- if items is not None and len(items) > 0:
+ if ordered_items is not None and len(ordered_items) > 0:
if with_tips:
self.fill()
else:
@@ -115,6 +113,10 @@ def __repr__(self) -> str:
return (f"{self.__class__.__name__}(name={self.name}, size_x={self._size_x}, "
f"size_y={self._size_y}, size_z={self._size_z}, location={self.location})")
+ @staticmethod
+ def _occupied_func(item: TipSpot):
+ return "V" if item.has_tip() else "-"
+
def get_tip(self, identifier: Union[str, int]) -> Tip:
""" Get the item with the given identifier.
@@ -131,23 +133,31 @@ def get_tips(self, identifier: Union[str, Sequence[int]]) -> List[Tip]:
return [ts.get_tip() for ts in super().get_items(identifier)]
- def set_tip_state(self, tips: List[List[bool]]) -> None:
+ def set_tip_state(self, tips: Union[List[bool], Dict[str, bool]]) -> None:
""" Set the initial tip tracking state of all tips in this tip rack.
+ Args:
+ tips: either a list of booleans (using integer indexing) or a dictionary of booleans (using
+ string indexing) for whether each tip should be filled or empty.
+
Examples:
Filling the right half of a 96-well tip rack:
>>> tip_rack.set_tip_state([[True] * 6 + [False] * 6] * 8)
"""
- for i in range(self.num_items_y):
- for j in range(self.num_items_x):
- # If the tip state is different from the current state, update it by either creating or
- # removing the tip.
- if tips[i][j] and not self.get_item((i, j)).has_tip():
- self.get_item((i, j)).tracker.add_tip(self.get_item((i, j)).make_tip(), commit=True)
- elif not tips[i][j] and self.get_item((i, j)).has_tip():
- self.get_item((i, j)).tracker.remove_tip(commit=True)
+ should_have: Dict[Union[int, str], bool] = {}
+ if isinstance(tips, list):
+ for i, tip in enumerate(tips):
+ should_have[i] = tip
+ else:
+ should_have = cast(Dict[Union[int, str], bool], tips) # type?
+
+ for identifier, should_have_tip in should_have.items():
+ if should_have_tip and not self.get_item(identifier).has_tip():
+ self.get_item(identifier).tracker.add_tip(self.get_item(identifier).make_tip(), commit=True)
+ elif not should_have_tip and self.get_item(identifier).has_tip():
+ self.get_item(identifier).tracker.remove_tip(commit=True)
def disable_tip_trackers(self) -> None:
""" Disable tip tracking for all tips in this tip rack. """
@@ -162,13 +172,62 @@ def enable_tip_trackers(self) -> None:
def empty(self):
""" Empty the tip rack. This is useful when tip tracking is enabled and you are modifying
the state manually (without the robot). """
- self.set_tip_state([[False] * self.num_items_x] * self.num_items_y)
+ self.set_tip_state([False] * self.num_items)
def fill(self):
""" Fill the tip rack. This is useful when tip tracking is enabled and you are modifying
the state manually (without the robot). """
- self.set_tip_state([[True] * self.num_items_x] * self.num_items_y)
+ self.set_tip_state([True] * self.num_items)
def get_all_tips(self) -> List[Tip]:
""" Get all tips in the tip rack. """
return [ts.get_tip() for ts in self.get_all_items()]
+
+
+class NestedTipRack(TipRack):
+ """ A nested tip rack. """
+ def __init__(
+ self,
+ name: str,
+ size_x: float,
+ size_y: float,
+ size_z: float,
+ stacking_z_height: float,
+ ordered_items: Optional[Dict[str, TipSpot]] = None,
+ ordering: Optional[List[str]] = None,
+ category: str = "tip_rack",
+ model: Optional[str] = None,
+ with_tips: bool = True,
+ ):
+ # Call the superclass constructor
+ super().__init__(
+ name=name,
+ size_x=size_x,
+ size_y=size_y,
+ size_z=size_z,
+ ordered_items=ordered_items,
+ ordering=ordering,
+ category=category,
+ model=model,
+ with_tips=with_tips
+ )
+
+ self.stacking_z_height = stacking_z_height
+
+ def __repr__(self) -> str:
+ return (f"{self.__class__.__name__}(name={self.name}, size_x={self._size_x}, "
+ f"size_y={self._size_y}, size_z={self._size_z}, "
+ f"stacking_z_height={self.stacking_z_height}, location={self.location})")
+
+ def assign_child_resource(
+ self,
+ resource: Resource,
+ location: Optional[Coordinate] = None,
+ reassign: bool = True
+ ):
+ if isinstance(resource, NestedTipRack):
+ location = location or Coordinate(0, 0, self.stacking_z_height)
+ else:
+ assert location is not None, "Location must be specified if " + \
+ "resource is not a NestedTipRack."
+ return super().assign_child_resource(resource, location=location, reassign=reassign)
diff --git a/pylabrobot/resources/trough.py b/pylabrobot/resources/trough.py
index e71af3739a..129643a552 100644
--- a/pylabrobot/resources/trough.py
+++ b/pylabrobot/resources/trough.py
@@ -1,7 +1,15 @@
-from typing import Optional
+import enum
+from typing import Callable, Optional, Union
from .container import Container
+class TroughBottomType(enum.Enum):
+ """ Enum for the type of bottom of a trough. """
+
+ FLAT = "flat"
+ U = "U"
+ V = "V"
+ UNKNOWN = "unknown"
class Trough(Container):
""" A trough is a container, particularly useful for multichannel liquid handling operations. """
@@ -13,15 +21,29 @@ def __init__(
size_y: float,
size_z: float,
max_volume: float,
+ material_z_thickness: Optional[float] = None,
+ through_base_to_container_base: float = 0,
category: Optional[str] = "trough",
- model: Optional[str] = None
+ model: Optional[str] = None,
+ bottom_type: Union[TroughBottomType, str] = TroughBottomType.UNKNOWN,
+ compute_volume_from_height: Optional[Callable[[float], float]] = None,
+ compute_height_from_volume: Optional[Callable[[float], float]] = None,
):
+
+ if isinstance(bottom_type, str):
+ bottom_type = TroughBottomType(bottom_type)
+
super().__init__(
name=name,
size_x=size_x,
size_y=size_y,
size_z=size_z,
+ material_z_thickness=material_z_thickness,
max_volume=max_volume,
category=category,
- model=model
+ model=model,
+ compute_volume_from_height=compute_volume_from_height,
+ compute_height_from_volume=compute_height_from_volume
)
+ self.through_base_to_container_base = through_base_to_container_base
+ self.bottom_type = bottom_type
diff --git a/pylabrobot/resources/tube.py b/pylabrobot/resources/tube.py
index 02782fa92f..109019c168 100644
--- a/pylabrobot/resources/tube.py
+++ b/pylabrobot/resources/tube.py
@@ -1,19 +1,57 @@
-from typing import Optional
+from typing import List, Optional, Tuple
from pylabrobot.resources.container import Container
-
+from pylabrobot.resources.liquid import Liquid
class Tube(Container):
- """ Tube container, like Eppendorf tubes. """
+ """ Tube container, like Eppendorf tubes.
+
+ Note that in regular use these will be automatically generated by the
+ :class:`pylabrobot.resources.TubeRack` class.
+ """
+
+ def __init__(self, name: str, size_x: float, size_y: float, size_z: float, max_volume: float,
+ material_z_thickness: Optional[float] = None, category: str = "tube",
+ model: Optional[str] = None):
+ """ Create a new tube.
+
+ Args:
+ name: Name of the tube.
+ size_x: Size of the tube in the x direction.
+ size_y: Size of the tube in the y direction.
+ size_z: Size of the tube in the z direction.
+ material_z_thickness: Tube base to cavity base.
+ max_volume: Maximum volume of the tube.
+ category: Category of the tube.
+ """
- def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
- category: str = "tube", max_volume: Optional[float] = None, model: Optional[str] = None):
super().__init__(
name=name,
size_x=size_x,
size_y=size_y,
size_z=size_z,
+ material_z_thickness=material_z_thickness,
category=category,
max_volume=max_volume,
model=model
)
+ self.tracker.register_callback(self._state_updated)
+
+ def serialize(self) -> dict:
+ return {
+ **super().serialize(),
+ "max_volume": self.max_volume
+ }
+
+ def set_liquids(self, liquids: List[Tuple[Optional["Liquid"], float]]):
+ """ Set the liquids in the tube.
+
+ (wraps :meth:`~.VolumeTracker.set_liquids`)
+
+ Example:
+ Set the liquids in a tube to 10 uL of water:
+
+ >>> tube.set_liquids([(Liquid.WATER, 10)])
+ """
+
+ self.tracker.set_liquids(liquids)
diff --git a/pylabrobot/resources/tube_rack.py b/pylabrobot/resources/tube_rack.py
index 22ef45e013..d42d96b830 100644
--- a/pylabrobot/resources/tube_rack.py
+++ b/pylabrobot/resources/tube_rack.py
@@ -1,8 +1,11 @@
-from typing import List, Optional
+from typing import Dict, List, Optional, Sequence, Tuple, Union, cast
from pylabrobot.resources.itemized_resource import ItemizedResource
from pylabrobot.resources.tube import Tube
+from .itemized_resource import ItemizedResource
+from .resource import Resource, Coordinate
+from .liquid import Liquid
class TubeRack(ItemizedResource[Tube]):
""" Tube rack resource. """
@@ -13,7 +16,7 @@ def __init__(
size_x: float,
size_y: float,
size_z: float,
- items: List[List[Tube]],
+ ordered_items: Optional[Dict[str, Tube]] = None,
model: Optional[str] = None,
):
""" Initialize a TubeRack resource.
@@ -31,17 +34,89 @@ def __init__(
size_x=size_x,
size_y=size_y,
size_z=size_z,
- items=items,
+ ordered_items=ordered_items,
model=model)
+ def assign_child_resource(
+ self,
+ resource: Resource,
+ location: Optional[Coordinate] = None,
+ reassign: bool = True
+ ):
+ assert location is not None, "Location must be specified for resource."
+ return super().assign_child_resource(resource, location=location, reassign=reassign)
+
+ def __repr__(self) -> str:
+ return (f"{self.__class__.__name__}(name={self.name}, size_x={self._size_x}, "
+ f"size_y={self._size_y}, size_z={self._size_z}, location={self.location})")
+
+ def get_tube(self, identifier: Union[str, int, Tuple[int, int]]) -> Tube:
+ """ Get the item with the given identifier.
+
+ See :meth:`~.get_item` for more information.
+ """
+
+ return super().get_item(identifier)
+
+ def get_tubes(self,
+ identifier: Union[str, Sequence[int]]) -> List[Tube]:
+ """ Get the tubes with the given identifier.
+
+ See :meth:`~.get_items` for more information.
+ """
+
+ return super().get_items(identifier)
+
+ def set_tube_liquids(
+ self,
+ liquids: Union[
+ List[List[Tuple[Optional["Liquid"], Union[int, float]]]],
+ List[Tuple[Optional["Liquid"], Union[int, float]]],
+ Tuple[Optional["Liquid"], Union[int, float]]]
+ ) -> None:
+
+ """ Update the liquid in the volume tracker for each tube in the rack.
+
+ Args:
+ liquids: A list of liquids, one for each tube in the rack. The list can be a list of lists,
+ where each inner list contains the liquids for each tube in a column. If a single tuple is
+ given, the volume is assumed to be the same for all tubes. Liquids are in uL.
+
+ Raises:
+ ValueError: If the number of liquids does not match the number of tubes in the rack.
+
+ Example:
+ Set the volume of each tube in a 4x6 rack to 1000 uL.
+
+ >>> rack = TubeRack("rack", 127.76, 85.48, 14.5, num_items_x=6, num_items_y=4)
+ >>> rack.set_tube_liquids((Liquid.WATER, 1000))
+ """
+
+ if isinstance(liquids, tuple):
+ liquids = [liquids] * self.num_items
+ elif isinstance(liquids, list) and all(isinstance(column, list) for column in liquids):
+ # mypy doesn't know that all() checks the type
+ liquids = cast(List[List[Tuple[Optional["Liquid"], float]]], liquids)
+ liquids = [list(column) for column in zip(*liquids)] # transpose the list of lists
+ liquids = [volume for column in liquids for volume in column] # flatten the list of lists
+
+ if len(liquids) != self.num_items:
+ raise ValueError(f"Number of liquids ({len(liquids)}) does not match number of tubes "
+ f"({self.num_items}) in rack '{self.name}'.")
+
+ for i, (liquid, volume) in enumerate(liquids):
+ tube = self.get_tube(i)
+ tube.tracker.set_liquids([(liquid, volume)]) # type: ignore
+
+
def disable_volume_trackers(self) -> None:
- """ Disable volume tracking for all wells in the plate. """
+ """ Disable volume tracking for all tubes in the rack. """
for tube in self.get_all_items():
tube.tracker.disable()
def enable_volume_trackers(self) -> None:
- """ Enable volume tracking for all wells in the plate. """
+ """ Enable volume tracking for all tubes in the rack. """
for tube in self.get_all_items():
tube.tracker.enable()
diff --git a/pylabrobot/resources/utils.py b/pylabrobot/resources/utils.py
index 066288ceba..a88b67d418 100644
--- a/pylabrobot/resources/utils.py
+++ b/pylabrobot/resources/utils.py
@@ -1,5 +1,6 @@
+import re
from string import ascii_uppercase as LETTERS
-from typing import Dict, List, Type, TypeVar
+from typing import Dict, List, Optional, Type, TypeVar
from pylabrobot.resources.coordinate import Coordinate
from pylabrobot.resources.resource import Resource
@@ -22,7 +23,7 @@ def create_equally_spaced_2d(
num_items_x: The number of items in the x direction
num_items_y: The number of items in the y direction
dx: The bottom left corner for items in the left column
- dy: The bottom left corner for items in the top row
+ dy: The bottom left corner for items in the bottom row
dz: The z coordinate for all items
item_dx: The size of the items in the x direction
item_dy: The size of the items in the y direction
@@ -64,7 +65,7 @@ def create_equally_spaced_x(
klass: The class of the resource to create
num_items_x: The number of items in the x direction
dx: The bottom left corner for items in the left column
- dy: The bottom left corner for items in the top row
+ dy: The bottom left corner for items in the bottom row
dz: The z coordinate for all items
item_dx: The size of the items in the x direction
**kwargs: Additional keyword arguments to pass to the resource constructor
@@ -98,7 +99,7 @@ def create_equally_spaced_y(
klass: The class of the resource to create
num_items_y: The number of items in the y direction
dx: The bottom left corner for items in the left column
- dy: The bottom left corner for items in the top row
+ dy: The bottom left corner for items in the bottom row
dz: The z coordinate for all items
item_dy: The size of the items in the y direction
**kwargs: Additional keyword arguments to pass to the resource constructor
@@ -133,7 +134,7 @@ def create_ordered_items_2d(
num_items_x: The number of items in the x direction
num_items_y: The number of items in the y direction
dx: The bottom left corner for items in the left column
- dy: The bottom left corner for items in the top row
+ dy: The bottom left corner for items in the bottom row
dz: The z coordinate for all items
item_dx: The size of the items in the x direction
item_dy: The size of the items in the y direction
@@ -154,3 +155,47 @@ def create_ordered_items_2d(
)
keys = [f"{LETTERS[j]}{i+1}" for i in range(num_items_x) for j in range(num_items_y)]
return dict(zip(keys, [item for sublist in items for item in sublist]))
+
+
+U = TypeVar("U", bound=Resource)
+def query(
+ root: Resource,
+ type_: Type[U] = Resource, # type: ignore
+ name: Optional[str] = None,
+ x: Optional[float] = None,
+ y: Optional[float] = None,
+ z: Optional[float] = None,
+) -> List[U]:
+ """ Query resources based on their attributes.
+
+ Args:
+ root: The root resource to search
+ type_: The type of resources to search for
+ name: The regular expression to match the name of the resources
+ x: The x-coordinate of the resources
+ y: The y-coordinate of the resources
+ z: The z-coordinate of the resources
+ """
+ matched: List[U] = []
+ for resource in root.children:
+ if type_ is not None and not isinstance(resource, type_):
+ continue
+ if name is not None and not re.match(name, resource.name):
+ continue
+ if x is not None and (resource.location is None or resource.location.x != x):
+ continue
+ if y is not None and (resource.location is None or resource.location.y != y):
+ continue
+ if z is not None and (resource.location is None or resource.location.z != z):
+ continue
+ matched.append(resource)
+
+ matched.extend(query(
+ root=resource,
+ type_=type_,
+ name=name,
+ x=x,
+ y=y,
+ z=z,
+ ))
+ return matched
diff --git a/pylabrobot/resources/utils_tests.py b/pylabrobot/resources/utils_tests.py
new file mode 100644
index 0000000000..b6570f3a01
--- /dev/null
+++ b/pylabrobot/resources/utils_tests.py
@@ -0,0 +1,37 @@
+from pylabrobot.resources.coordinate import Coordinate
+from pylabrobot.resources.resource import Resource
+from pylabrobot.resources.utils import query
+from pylabrobot.resources.well import Well
+
+
+def test_query():
+ root = Resource(name="root", size_x=10, size_y=10, size_z=10)
+ child1 = Resource(name="child1", size_x=5, size_y=5, size_z=5)
+ child2 = Resource(name="child2", size_x=5, size_y=5, size_z=5)
+ child3 = Resource(name="odd", size_x=5, size_y=5, size_z=5)
+ root.assign_child_resource(child1, location=Coordinate(0, 0, 0))
+ root.assign_child_resource(child2, location=Coordinate(5, 0, 0))
+ root.assign_child_resource(child3, location=Coordinate(0, 5, 0))
+
+ assert query(root, Resource) == [child1, child2, child3]
+ assert query(root, Resource, x=0) == [child1, child3]
+ assert query(root, Resource, y=0) == [child1, child2]
+ assert query(root, name=r"child\d") == [child1, child2]
+
+def test_query_with_type():
+ root = Resource(name="root", size_x=10, size_y=10, size_z=10)
+ well1 = Well(name="well", size_x=3, size_y=3, size_z=3)
+ well2 = Well(name="well", size_x=3, size_y=3, size_z=3)
+ root.assign_child_resource(well1, location=Coordinate(6, 1, 0))
+ root.assign_child_resource(well2, location=Coordinate(6, 6, 0))
+ assert query(root, Well) == [well1, well2]
+ assert query(root, Well, x=6) == [well1, well2]
+
+def test_deep():
+ root = Resource(name="root", size_x=10, size_y=10, size_z=10)
+ child1 = Resource(name="child1", size_x=5, size_y=5, size_z=5)
+ grandchild = Resource(name="grandchild", size_x=2, size_y=2, size_z=2)
+ root.assign_child_resource(child1, location=Coordinate(0, 0, 0))
+ child1.assign_child_resource(grandchild, location=Coordinate(1, 1, 0))
+
+ assert query(root, Resource) == [child1, grandchild]
diff --git a/pylabrobot/resources/volume_functions.py b/pylabrobot/resources/volume_functions.py
index eabbbff73a..cfc4835d17 100644
--- a/pylabrobot/resources/volume_functions.py
+++ b/pylabrobot/resources/volume_functions.py
@@ -1,8 +1,3 @@
-# General use functions for calculating the volume of different container geometries
-
-import math
-
-
def calculate_liquid_volume_container_2segments_square_vbottom(
x: float,
y: float,
@@ -11,48 +6,11 @@ def calculate_liquid_volume_container_2segments_square_vbottom(
liquid_height: float
) -> float:
"""
- Calculate the volume of liquid in a container consisting of an upside-down
- square pyramid at the bottom and a cuboid on top. The container has the
- same x and y dimensions for both the pyramid and the cuboid.
-
- The function calculates the volume based on whether the liquid height is within
- the pyramid or extends into the cuboid.
-
- Parameters:
- x (float): The base length of the square pyramid and cube in mm.
- y (float): The base width of the square pyramid and cube in mm.
- h_pyramid (float): The height of the square pyramid in mm.
- h_cube (float): The height of the cube in mm.
- liquid_height (float): The height of the liquid in the container in mm.
-
- Returns:
- float: The volume of the liquid in cubic millimeters.
+ This function is deprecated. Please use the equivalent function in
+ src/pylabrobot/pylabrobot/resources/height_volume_functions.py
"""
- if liquid_height > h_pyramid + h_cube:
- raise ValueError("""WARNING: Liquid overflow detected;
- check your labware definiton and/or that you are using the right labware.""")
-
- # Calculating the base area
- base_area = x * y
-
- # Calculating the full volume of the pyramid
- full_pyramid_volume = (1/3) * base_area * h_pyramid
-
- if liquid_height <= h_pyramid:
- # Liquid height is within the pyramid
- # Calculating the scale factor for the reduced height
- scale_factor = liquid_height / h_pyramid
- # Calculating the sub-volume of the pyramid
- liquid_volume = full_pyramid_volume * (scale_factor ** 3)
- else:
- # Liquid height extends into the cube
- # Calculating the volume of the cube portion filled with liquid
- cube_liquid_height = liquid_height - h_pyramid
- cube_liquid_volume = base_area * cube_liquid_height
- # Total liquid volume is the sum of the pyramid and cube volumes
- liquid_volume = full_pyramid_volume + cube_liquid_volume
-
- return float(liquid_volume)
+ raise DeprecationWarning("This function is deprecated. Please use the equivalent function in "
+ "src/pylabrobot/pylabrobot/resources/height_volume_functions.py")
def calculate_liquid_volume_container_2segments_square_ubottom(
@@ -61,40 +19,11 @@ def calculate_liquid_volume_container_2segments_square_ubottom(
liquid_height: float
) -> float:
"""
- Calculate the volume of liquid in a container with a hemispherical bottom and a cuboidal top.
- The diameter of the hemisphere is equal to the side length of the square base of the cuboid.
-
- The function calculates the volume based on whether the liquid height is within the hemisphere or
- extends into the cuboid.
-
- Parameters:
- x: The side length of the square base of the cuboid and diameter of the hemisphere in mm.
- h_cuboid: The height of the cuboid in mm.
- liquid_height: The height of the liquid in the container in mm.
-
- Returns:
- The volume of the liquid in cubic millimeters.
+ This function is deprecated. Please use the equivalent function in
+ src/pylabrobot/pylabrobot/resources/height_volume_functions.py
"""
- if liquid_height > h_cuboid + x/2:
- raise ValueError("""WARNING: Liquid overflow detected;
- check your labware definiton and/or that you are using the right labware.""")
-
- r = x / 2 # Radius of the hemisphere
- full_hemisphere_volume = (2/3) * math.pi * r**3
-
- if liquid_height <= r:
- # Liquid height is within the hemisphere
- # Calculating the sub-volume of the hemisphere using spherical cap volume formula
- h = liquid_height # Height of the spherical cap
- liquid_volume = (1/3) * math.pi * h**2 * (3*r - h)
- else:
- # Liquid height extends into the cuboid
- # Calculating the volume of the cuboid portion filled with liquid
- cuboid_liquid_height = liquid_height - r
- cuboid_liquid_volume = x**2 * cuboid_liquid_height
- liquid_volume = full_hemisphere_volume + cuboid_liquid_volume
-
- return liquid_volume
+ raise DeprecationWarning("This function is deprecated. Please use the equivalent function in "
+ "src/pylabrobot/pylabrobot/resources/height_volume_functions.py")
def calculate_liquid_volume_container_2segments_round_vbottom(
@@ -104,45 +33,11 @@ def calculate_liquid_volume_container_2segments_round_vbottom(
liquid_height: float
) -> float:
"""
- Calculate the volume of liquid in a container with a conical bottom and
- a cylindrical top. The container has the same radius for both the cone and
- the cylinder.
-
- The function calculates the volume based on whether the liquid height is
- within the cone or extends into the cylinder.
-
- Parameters:
- d (float): The diameter of the base of the cone and cylinder in mm.
- h_cone (float): The height of the cone in mm.
- h_cylinder (float): The height of the cylinder in mm.
- liquid_height (float): The height of the liquid in the container in mm.
-
- Returns:
- float: The volume of the liquid in cubic millimeters.
+ This function is deprecated. Please use the equivalent function in
+ src/pylabrobot/pylabrobot/resources/height_volume_functions.py
"""
- if liquid_height > h_cone+h_cylinder:
- raise ValueError("""WARNING: Liquid overflow detected;
- check your labware definiton and/or that you are using the right labware.""")
-
- r = d/2
- # Calculating the full volume of the cone
- full_cone_volume = (1/3) * math.pi * r**2 * h_cone
-
- if liquid_height <= h_cone:
- # Liquid height is within the cone
- # Calculating the scale factor for the reduced height
- scale_factor = liquid_height / h_cone
- # Calculating the sub-volume of the cone
- liquid_volume = full_cone_volume * (scale_factor ** 3)
- else:
- # Liquid height extends into the cylinder
- # Calculating the volume of the cylinder portion filled with liquid
- cylinder_liquid_height = liquid_height - h_cone
- cylinder_liquid_volume = math.pi * r**2 * cylinder_liquid_height
- # Total liquid volume is the sum of the cone and cylinder volumes
- liquid_volume = full_cone_volume + cylinder_liquid_volume
-
- return float(liquid_volume)
+ raise DeprecationWarning("This function is deprecated. Please use the equivalent function in "
+ "src/pylabrobot/pylabrobot/resources/height_volume_functions.py")
def calculate_liquid_volume_container_2segments_round_ubottom(
@@ -151,40 +46,21 @@ def calculate_liquid_volume_container_2segments_round_ubottom(
liquid_height: float
) -> float:
"""
- Calculate the volume of liquid in a container with a hemispherical bottom
- and a cylindrical top. The container has the same radius for both the
- hemisphere and the cylinder.
-
- The function calculates the volume based on whether the liquid height is
- within the hemisphere or extends into the cylinder.
-
- Parameters:
- d (float): The diameter of the base of the hemisphere and cylinder in mm.
- h_cylinder (float): The height of the cylinder in mm.
- liquid_height (float): The height of the liquid in the container in mm.
-
- Returns:
- float: The volume of the liquid in cubic millimeters.
+ This function is deprecated. Please use the equivalent function in
+ src/pylabrobot/pylabrobot/resources/height_volume_functions.py
"""
- r = d/2
- if liquid_height > h_cylinder+r:
- raise ValueError("""WARNING: Liquid overflow detected;
- check your labware definiton and/or that you are using the right labware.""")
-
- # Calculating the full volume of the hemisphere
- full_hemisphere_volume = (2/3) * math.pi * r**3
+ raise DeprecationWarning("This function is deprecated. Please use the equivalent function in "
+ "src/pylabrobot/pylabrobot/resources/height_volume_functions.py")
- if liquid_height <= r:
- # Liquid height is within the hemisphere
- # Calculating the sub-volume of the hemisphere using spherical cap volume formula
- h = liquid_height # Height of the spherical cap
- liquid_volume = (1/3) * math.pi * h**2 * (3*r - h)
- else:
- # Liquid height extends into the cylinder
- # Calculating the volume of the cylinder portion filled with liquid
- cylinder_liquid_height = liquid_height - r
- cylinder_liquid_volume = math.pi * r**2 * cylinder_liquid_height
- # Total liquid volume is the sum of the hemisphere and cylinder volumes
- liquid_volume = full_hemisphere_volume + cylinder_liquid_volume
- return float(liquid_volume)
+def calculate_liquid_volume_container_1segment_round_fbottom(
+ d: float,
+ h_cylinder: float,
+ liquid_height: float
+) -> float:
+ """
+ This function is deprecated. Please use the equivalent function in
+ src/pylabrobot/pylabrobot/resources/height_volume_functions.py
+ """
+ raise DeprecationWarning("This function is deprecated. Please use the equivalent function in "
+ "src/pylabrobot/pylabrobot/resources/height_volume_functions.py")
diff --git a/pylabrobot/resources/volume_functions_tests.py b/pylabrobot/resources/volume_functions_tests.py
index 557696b5f3..8766e390a2 100644
--- a/pylabrobot/resources/volume_functions_tests.py
+++ b/pylabrobot/resources/volume_functions_tests.py
@@ -1,7 +1,7 @@
import math
import unittest
-from pylabrobot.resources.volume_functions import (
+from pylabrobot.resources.height_volume_functions import (
calculate_liquid_volume_container_2segments_square_vbottom,
calculate_liquid_volume_container_2segments_round_vbottom,
calculate_liquid_volume_container_2segments_round_ubottom,
diff --git a/pylabrobot/resources/volume_tracker.py b/pylabrobot/resources/volume_tracker.py
index ce5ace5de9..a37e82589c 100644
--- a/pylabrobot/resources/volume_tracker.py
+++ b/pylabrobot/resources/volume_tracker.py
@@ -10,20 +10,40 @@
this = sys.modules[__name__]
this.volume_tracking_enabled = False # type: ignore
+this.cross_contamination_tracking_enabled = False # type: ignore
def set_volume_tracking(enabled: bool):
this.volume_tracking_enabled = enabled # type: ignore
+ if not enabled:
+ this.cross_contamination_tracking_enabled = False # type: ignore
def does_volume_tracking() -> bool:
return this.volume_tracking_enabled # type: ignore
@contextlib.contextmanager
def no_volume_tracking():
- old_value = this.volume_tracking_enabled
+ vt, ct = this.volume_tracking_enabled, this.cross_contamination_tracking_enabled # type: ignore
this.volume_tracking_enabled = False # type: ignore
+ this.cross_contamination_tracking_enabled = False # type: ignore
yield
- this.volume_tracking_enabled = old_value # type: ignore
+ this.volume_tracking_enabled = vt # type: ignore
+ this.cross_contamination_tracking_enabled = ct # type: ignore
+def set_cross_contamination_tracking(enabled: bool):
+ if enabled:
+ assert this.volume_tracking_enabled, \
+ "Cross contamination tracking only possible if volume tracking active."
+ this.cross_contamination_tracking_enabled = enabled # type: ignore
+
+def does_cross_contamination_tracking() -> bool:
+ return this.cross_contamination_tracking_enabled # type: ignore
+
+@contextlib.contextmanager
+def no_cross_contamination_tracking():
+ old_value = this.cross_contamination_tracking_enabled
+ this.cross_contamination_tracking_enabled = False # type: ignore
+ yield
+ this.cross_contamination_tracking_enabled = old_value # type: ignore
VolumeTrackerCallback = Callable[[], None]
@@ -36,32 +56,52 @@ def __init__(
self,
max_volume: float,
liquids: Optional[List[Tuple[Optional[Liquid], float]]] = None,
- pending_liquids: Optional[List[Tuple[Optional[Liquid], float]]] = None
+ pending_liquids: Optional[List[Tuple[Optional[Liquid], float]]] = None,
+ liquid_history: Optional[set] = None
) -> None:
self._is_disabled = False
+ self._is_cross_contamination_tracking_disabled = False
self.max_volume = max_volume
self.liquids: List[Tuple[Optional[Liquid], float]] = liquids or []
self.pending_liquids: List[Tuple[Optional[Liquid], float]] = pending_liquids or []
+ self.liquid_history = {liquid for liquid in (liquid_history or set()) if liquid is not None}
+
self._callback: Optional[VolumeTrackerCallback] = None
@property
def is_disabled(self) -> bool:
return self._is_disabled
+ @property
+ def is_cross_contamination_tracking_disabled(self) -> bool:
+ return self._is_cross_contamination_tracking_disabled
+
def disable(self) -> None:
""" Disable the volume tracker. """
self._is_disabled = True
+ def disable_cross_contamination_tracking(self) -> None:
+ """ Disable the cross contamination tracker. """
+ self._is_cross_contamination_tracking_disabled = True
+
def enable(self) -> None:
""" Enable the volume tracker. """
self._is_disabled = False
+ def enable_cross_contamination_tracking(self) -> None:
+ """ Enable the cross contamination tracker. """
+ self._is_cross_contamination_tracking_disabled = False
+
def set_liquids(self, liquids: List[Tuple[Optional["Liquid"], float]]) -> None:
""" Set the liquids in the container. """
self.liquids = liquids
self.pending_liquids = liquids
+
+ if not self.is_cross_contamination_tracking_disabled:
+ self.liquid_history.update([l[0] for l in liquids])
+
if self._callback is not None:
self._callback()
@@ -85,6 +125,9 @@ def remove_liquid(self, volume: float) -> List[Tuple[Optional["Liquid"], float]]
else:
removed_liquids.append((liquid, liquid_volume))
+ if self._callback is not None:
+ self._callback()
+
return removed_liquids
def add_liquid(self, liquid: Optional["Liquid"], volume: float) -> None:
@@ -94,6 +137,11 @@ def add_liquid(self, liquid: Optional["Liquid"], volume: float) -> None:
raise TooLittleVolumeError(
f"Container has too little volume: {volume}uL > {self.get_free_volume()}uL.")
+ # Update the liquid history tracker if needed
+ if not self.is_cross_contamination_tracking_disabled:
+ if liquid is not None:
+ self.liquid_history.add(liquid)
+
# If the last liquid is the same as the one we want to add, just add the volume to it.
if len(self.pending_liquids) > 0:
last_pending_liquid_tuple = self.pending_liquids[-1]
@@ -104,6 +152,9 @@ def add_liquid(self, liquid: Optional["Liquid"], volume: float) -> None:
else:
self.pending_liquids.append((liquid, volume))
+ if self._callback is not None:
+ self._callback()
+
def get_used_volume(self) -> float:
""" Get the used volume of the container. Note that this includes pending operations. """
return sum(volume for _, volume in self.pending_liquids)
@@ -146,9 +197,21 @@ def rollback(self) -> None:
assert not self.is_disabled, "Volume tracker is disabled. Call `enable()`."
self.pending_liquids.clear()
+ def clear_cross_contamination_history(self) -> None:
+ """ Resets the liquid_history for cross contamination tracking. Use when there is a wash step.
+ """
+ self.liquid_history.clear()
+
def serialize(self) -> dict:
""" Serialize the volume tracker. """
+ if not self.is_cross_contamination_tracking_disabled:
+ return {
+ "liquids": [serialize(l) for l in self.liquids],
+ "pending_liquids": [serialize(l) for l in self.pending_liquids],
+ "liquid_history": [serialize(l) for l in self.liquid_history],
+ }
+
return {
"liquids": [serialize(l) for l in self.liquids],
"pending_liquids": [serialize(l) for l in self.pending_liquids],
@@ -163,5 +226,8 @@ def load_liquid(data) -> Tuple[Optional["Liquid"], float]:
self.liquids = [load_liquid(l) for l in state["liquids"]]
self.pending_liquids = [load_liquid(l) for l in state["pending_liquids"]]
+ if not self.is_cross_contamination_tracking_disabled:
+ self.liquid_history = set(state["liquid_history"])
+
def register_callback(self, callback: VolumeTrackerCallback) -> None:
self._callback = callback
diff --git a/pylabrobot/resources/well.py b/pylabrobot/resources/well.py
index 7e66994cae..ddbfbd1de3 100644
--- a/pylabrobot/resources/well.py
+++ b/pylabrobot/resources/well.py
@@ -34,10 +34,16 @@ class Well(Container):
:class:`pylabrobot.resources.Plate` class.
"""
- def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
- bottom_type: Union[WellBottomType, str] = WellBottomType.UNKNOWN, category: str = "well",
- max_volume: Optional[float] = None, model: Optional[str] = None,
+ def __init__(
+ self,
+ name: str,
+ size_x: float, size_y: float, size_z: float,
+ material_z_thickness: Optional[float] = None,
+ bottom_type: Union[WellBottomType, str] = WellBottomType.UNKNOWN,
+ category: str = "well", model: Optional[str] = None,
+ max_volume: Optional[float] = None,
compute_volume_from_height: Optional[Callable[[float], float]] = None,
+ compute_height_from_volume: Optional[Callable[[float], float]] = None,
cross_section_type: Union[CrossSectionType, str] = CrossSectionType.CIRCLE):
""" Create a new well.
@@ -74,9 +80,10 @@ def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
max_volume = compute_volume_from_height(size_z)
super().__init__(name, size_x=size_x, size_y=size_y, size_z=size_z, category=category,
- max_volume=max_volume, model=model)
+ max_volume=max_volume, model=model, compute_volume_from_height=compute_volume_from_height,
+ compute_height_from_volume=compute_height_from_volume,
+ material_z_thickness=material_z_thickness)
self.bottom_type = bottom_type
- self._compute_volume_from_height = compute_volume_from_height
self.cross_section_type = cross_section_type
self.tracker.register_callback(self._state_updated)
@@ -88,25 +95,6 @@ def serialize(self):
"cross_section_type": self.cross_section_type.value,
}
- def compute_volume_from_height(self, height: float) -> float:
- """ Compute the volume of liquid in a well from the height of the liquid relative to the bottom
- of the well.
-
- Args:
- height: Height of the liquid in the well relative to the bottom.
-
- Returns:
- The volume of liquid in the well.
-
- Raises:
- NotImplementedError: If the plate does not have a volume computation function.
- """
-
- if self._compute_volume_from_height is None:
- raise NotImplementedError("compute_volume_from_height not implemented.")
-
- return self._compute_volume_from_height(height)
-
def set_liquids(self, liquids: List[Tuple[Optional["Liquid"], float]]):
""" Set the liquids in the well.
diff --git a/pylabrobot/resources/well_tests.py b/pylabrobot/resources/well_tests.py
index cfb1c355eb..bcafb76eb7 100644
--- a/pylabrobot/resources/well_tests.py
+++ b/pylabrobot/resources/well_tests.py
@@ -14,6 +14,7 @@ def test_serialize(self):
"size_x": 1,
"size_y": 2,
"size_z": 3,
+ "material_z_thickness": None,
"bottom_type": "flat",
"cross_section_type": "circle",
"max_volume": 10,
@@ -24,6 +25,12 @@ def test_serialize(self):
"type": "Well",
"parent_name": None,
"location": None,
+ "rotation": {
+ "type": "Rotation",
+ "x": 0, "y": 0, "z": 0
+ },
+ "compute_volume_from_height": None,
+ "compute_height_from_volume": None,
})
self.assertEqual(Well.deserialize(well.serialize()), well)
diff --git a/pylabrobot/scales/chatterbox.py b/pylabrobot/scales/chatterbox.py
new file mode 100644
index 0000000000..b451538000
--- /dev/null
+++ b/pylabrobot/scales/chatterbox.py
@@ -0,0 +1,24 @@
+from pylabrobot.scales.scale_backend import ScaleBackend
+
+
+class ScaleChatterboxBackend(ScaleBackend):
+ """ Chatter box backend for device-free testing. Prints out all operations. """
+
+ def __init__(self, dummy_weight: float = 0.0) -> None:
+ self._dummy_weight = dummy_weight
+
+ async def setup(self) -> None:
+ print("Setting up the scale.")
+
+ async def stop(self) -> None:
+ print("Stopping the scale.")
+
+ async def tare(self):
+ print("Taring the scale")
+
+ async def get_weight(self) -> float:
+ print("Getting the weight")
+ return self._dummy_weight
+
+ async def zero(self):
+ print("Zeroing the scale")
diff --git a/pylabrobot/scales/mettler_toledo.py b/pylabrobot/scales/mettler_toledo.py
index 606e54d60b..eeb3620304 100644
--- a/pylabrobot/scales/mettler_toledo.py
+++ b/pylabrobot/scales/mettler_toledo.py
@@ -132,18 +132,19 @@ def __init__(self, port: str) -> None:
self.ser: Optional[serial.Serial] = None
async def setup(self) -> None:
- await super().setup()
self.ser = serial.Serial(self.port, baudrate=9600, timeout=1)
# set output unit to grams
await self.send_command("M21 0 0")
async def stop(self) -> None:
- await super().stop()
if self.ser is not None:
self.ser.close()
self.ser = None
+ def serialize(self) -> dict:
+ return {**super().serialize(), "port": self.port}
+
async def send_command(self, command: str, timeout: int = 60) -> MettlerToledoResponse:
""" Send a command to the scale and receive the response.
diff --git a/pylabrobot/scales/scale.py b/pylabrobot/scales/scale.py
index c39d6e2b1c..83c49e8a63 100644
--- a/pylabrobot/scales/scale.py
+++ b/pylabrobot/scales/scale.py
@@ -1,6 +1,6 @@
from typing import Optional
-from pylabrobot.machine import Machine
+from pylabrobot.machines.machine import Machine
from pylabrobot.scales.scale_backend import ScaleBackend
diff --git a/pylabrobot/scales/scale_backend.py b/pylabrobot/scales/scale_backend.py
index bb6ea23bca..4af3b940af 100644
--- a/pylabrobot/scales/scale_backend.py
+++ b/pylabrobot/scales/scale_backend.py
@@ -1,5 +1,5 @@
from abc import ABCMeta, abstractmethod
-from pylabrobot.machine import MachineBackend
+from pylabrobot.machines.backends import MachineBackend
class ScaleBackend(MachineBackend, metaclass=ABCMeta):
diff --git a/pylabrobot/serializer.py b/pylabrobot/serializer.py
index aae3935710..5c977813ed 100644
--- a/pylabrobot/serializer.py
+++ b/pylabrobot/serializer.py
@@ -2,7 +2,9 @@
import enum
import inspect
+import marshal
import sys
+import types
from typing import Any, Dict, List, Union, cast
if sys.version_info >= (3, 10):
@@ -35,12 +37,23 @@ def serialize(obj: Any) -> JSON:
return {k: serialize(v) for k, v in obj.items()}
if isinstance(obj, enum.Enum):
return obj.name
+ if inspect.isfunction(obj):
+ return {
+ "type": "function",
+ "code": marshal.dumps(obj.__code__).hex(),
+ "closure": serialize(obj.__closure__) if obj.__closure__ else None
+ }
+ if isinstance(obj, types.CellType):
+ return {
+ "type": "cell",
+ "contents": serialize(obj.cell_contents)
+ }
if isinstance(obj, object):
if hasattr(obj, "serialize"): # if the object has a custom serialize method
return cast(JSON, obj.serialize())
else:
data: Dict[str, Any] = {}
- for key, value in obj.__dict__.items():
+ for key, value in vars(obj).items():
if key.startswith("_"):
continue
data[key] = serialize(value)
@@ -49,19 +62,29 @@ def serialize(obj: Any) -> JSON:
raise TypeError(f"Cannot serialize {obj} of type {type(obj)}")
-def deserialize(data: JSON) -> Any:
+def deserialize(data: JSON, allow_marshal: bool = False) -> Any:
""" Deserialize an object. """
if isinstance(data, (int, float, str, bool, type(None))):
return data
if isinstance(data, list):
- return [deserialize(item) for item in data]
+ return [deserialize(item, allow_marshal=allow_marshal) for item in data]
if isinstance(data, dict):
if "type" in data: # deserialize a class
data = data.copy()
klass_type = cast(str, data.pop("type"))
+ if klass_type == "function" and allow_marshal:
+ assert isinstance(data["code"], str)
+ code = marshal.loads(bytes.fromhex(data["code"]))
+ closure = tuple(deserialize(data["closure"], allow_marshal=allow_marshal)) \
+ if data["closure"] else None
+ return types.FunctionType(code, globals(), closure=closure)
+ if klass_type == "cell":
+ return types.CellType(deserialize(data["contents"], allow_marshal=allow_marshal))
klass = get_plr_class_from_string(klass_type)
- params = {k: deserialize(v) for k, v in data.items()}
+ params = {k: deserialize(v, allow_marshal=allow_marshal) for k, v in data.items()}
return klass(**params)
- return {k: deserialize(v) for k, v in data.items()}
+ return {k: deserialize(v, allow_marshal=allow_marshal) for k, v in data.items()}
+ if isinstance(data, object):
+ return data
raise TypeError(f"Cannot deserialize {data} of type {type(data)}")
diff --git a/pylabrobot/server/liquid_handling_api_tests.py b/pylabrobot/server/liquid_handling_api_tests.py
index 3b9554f18a..a37a676928 100644
--- a/pylabrobot/server/liquid_handling_api_tests.py
+++ b/pylabrobot/server/liquid_handling_api_tests.py
@@ -1,14 +1,17 @@
+import logging
+from pathlib import Path
import time
from typing import cast
import unittest
+from pylabrobot import Config
from pylabrobot.liquid_handling import LiquidHandler
from pylabrobot.liquid_handling.backends import SerializingSavingBackend
from pylabrobot.resources import (
Plate,
TipRack,
HTF_L,
- Cos_96_EZWash,
+ Cor_96_wellplate_360ul_Fb,
TIP_CAR_480_A00,
PLT_CAR_L5AC_A00,
no_tip_tracking,
@@ -24,7 +27,7 @@ def build_layout() -> HamiltonDeck:
tip_car[0] = HTF_L(name="tip_rack_01")
plt_car = PLT_CAR_L5AC_A00(name="plate_carrier")
- plt_car[0] = plate = Cos_96_EZWash(name="aspiration plate")
+ plt_car[0] = plate = Cor_96_wellplate_360ul_Fb(name="aspiration plate")
plate.get_item("A1").tracker.set_liquids([(None, 400)])
deck = STARLetDeck()
@@ -33,6 +36,17 @@ def build_layout() -> HamiltonDeck:
return deck
+def _wait_for_task_done(base_url, client, task_id):
+ while True:
+ response = client.get(base_url + f"/tasks/{task_id}")
+ if response.json is None:
+ raise RuntimeError("No JSON in response: " + response.text)
+ if response.json.get("status") == "running":
+ time.sleep(0.1)
+ else:
+ return response
+
+
class LiquidHandlingApiGeneralTests(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.backend = SerializingSavingBackend(num_channels=8)
@@ -49,19 +63,23 @@ def test_get_index(self):
def test_setup(self): # TODO: Figure out how we can configure LH
with self.app.test_client() as client:
- response = client.post(self.base_url + "/setup")
+ task = client.post(self.base_url + "/setup")
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
self.assertEqual(response.status_code, 200)
-
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ self.assertEqual(response.json.get("status"), "succeeded")
time.sleep(0.1)
assert self.lh.setup_finished
def test_stop(self):
with self.app.test_client() as client:
- response = client.post(self.base_url + "/stop")
+ task = client.post(self.base_url + "/setup")
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
+
+ task = client.post(self.base_url + "/stop")
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
self.assertEqual(response.status_code, 200)
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ self.assertEqual(response.json.get("status"), "succeeded")
assert not self.lh.setup_finished
@@ -74,7 +92,12 @@ async def test_status(self):
await self.lh.setup()
response = client.get(self.base_url + "/status")
self.assertEqual(response.status_code, 200)
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ self.assertEqual(response.json.get("status"), "running")
+
+ await self.lh.stop()
+ response = client.get(self.base_url + "/status")
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(response.json.get("status"), "stopped")
def test_load_labware(self):
with self.app.test_client() as client:
@@ -121,14 +144,15 @@ def test_tip_pickup(self):
tip_spot = tip_rack.get_item("A1")
with no_tip_tracking():
tip = tip_spot.get_tip()
- response = client.post(
+ task = client.post(
self.base_url + "/pick-up-tips",
json={"channels": [{
"resource_name": tip_spot.name,
"tip": serialize(tip),
"offset": None,
}], "use_channels": [0]})
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
+ self.assertEqual(response.json.get("status"), "succeeded")
self.assertEqual(response.status_code, 200)
def test_drop_tip(self):
@@ -140,14 +164,15 @@ def test_drop_tip(self):
self.test_tip_pickup() # Pick up a tip first
- response = client.post(
+ task = client.post(
self.base_url + "/drop-tips",
json={"channels": [{
"resource_name": tip_spot.name,
"tip": serialize(tip),
"offset": None,
}], "use_channels": [0]})
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
+ self.assertEqual(response.json.get("status"), "succeeded")
self.assertEqual(response.status_code, 200)
def test_aspirate(self):
@@ -156,19 +181,20 @@ def test_aspirate(self):
self.test_tip_pickup() # pick up a tip first
with self.app.test_client() as client:
well = cast(Plate, self.lh.deck.get_resource("aspiration plate")).get_item("A1")
- response = client.post(
+ task = client.post(
self.base_url + "/aspirate",
json={"channels": [{
"resource_name": well.name,
"volume": 10,
"tip": serialize(tip),
- "offset": None,
+ "offset": {"type": "Coordinate", "x": 0, "y": 0, "z": 0},
"liquids": [[None, 10]],
"flow_rate": None,
"liquid_height": None,
"blow_out_air_volume": 0,
}], "use_channels": [0]})
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
+ self.assertEqual(response.json.get("status"), "succeeded")
self.assertEqual(response.status_code, 200)
def test_dispense(self):
@@ -177,17 +203,37 @@ def test_dispense(self):
self.test_aspirate() # aspirate first
with self.app.test_client() as client:
well = cast(Plate, self.lh.deck.get_resource("aspiration plate")).get_item("A1")
- response = client.post(
+ task = client.post(
self.base_url + "/dispense",
json={"channels": [{
"resource_name": well.name,
"volume": 10,
"tip": serialize(tip),
- "offset": None,
+ "offset": {"type": "Coordinate", "x": 0, "y": 0, "z": 0},
"liquids": [[None, 10]],
"flow_rate": None,
"liquid_height": None,
"blow_out_air_volume": 0,
}], "use_channels": [0]})
- self.assertIn(response.json.get("status"), {"running", "succeeded"})
+ response = _wait_for_task_done(self.base_url, client, task.json.get("id"))
+ self.assertEqual(response.json.get("status"), "succeeded")
+ self.assertEqual(response.status_code, 200)
+
+ def test_config(self):
+ cfg = Config(
+ logging=Config.Logging(
+ log_dir=Path("logs"),
+ level=logging.CRITICAL
+ )
+ )
+ with self.app.test_client() as client:
+ logger = logging.getLogger("pylabrobot")
+ cur_level = logger.level
+ response = client.post(
+ self.base_url + "/config",
+ json=cfg.as_dict)
+ new_level = logging.getLogger("pylabrobot").level
+ self.assertEqual(response.json, cfg.as_dict)
self.assertEqual(response.status_code, 200)
+ self.assertEqual(new_level, logging.CRITICAL)
+ self.assertNotEqual(cur_level, new_level)
diff --git a/pylabrobot/server/liquid_handling_server.py b/pylabrobot/server/liquid_handling_server.py
index 94aa3532ba..7aa8e8e19a 100644
--- a/pylabrobot/server/liquid_handling_server.py
+++ b/pylabrobot/server/liquid_handling_server.py
@@ -5,18 +5,21 @@
import json
import os
import threading
-from typing import Any, Coroutine, List, Tuple, Type, Optional, cast
+from typing import Any, Coroutine, List, Tuple, Optional, cast
-from flask import Blueprint, Flask, request, jsonify, current_app
+from flask import Blueprint, Flask, request, jsonify, current_app, Request
import werkzeug
+from pylabrobot import configure, Config
+from pylabrobot.config.io import ConfigReader
+from pylabrobot.config.formats.json_config import JsonLoader
from pylabrobot.liquid_handling import LiquidHandler
from pylabrobot.liquid_handling.backends.backend import LiquidHandlerBackend
-from pylabrobot.liquid_handling.standard import Pickup, Aspiration, Dispense, Drop
+from pylabrobot.liquid_handling.standard import Pickup, Aspiration, Dispense, \
+ Drop
from pylabrobot.resources import Coordinate, Deck, Tip, Liquid
from pylabrobot.serializer import deserialize
-
lh_api = Blueprint("liquid handling", __name__)
@@ -31,13 +34,14 @@ def __init__(self, co: Coroutine[Any, Any, None]):
def run_in_thread(self) -> None:
""" Run the coroutine in a new thread. """
+
def runner():
self.status = "running"
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(self.co)
- except Exception as e: # pylint: disable=broad-except
+ except Exception as e: # pylint: disable=broad-except
self.error = str(e)
self.status = "error"
else:
@@ -52,8 +56,10 @@ def serialize(self, id_: int) -> dict:
d["error"] = self.error
return d
+
tasks: List[Task] = []
+
def add_and_run_task(task: Task):
id_ = len(tasks)
tasks.append(task)
@@ -70,6 +76,7 @@ def index():
def get_tasks():
return jsonify([{"id": i, "status": t.status} for i, t in enumerate(tasks)])
+
@lh_api.route("/tasks/