def test_compound_units(self):
u1 = Unit(20, 'microliter/second')
u2 = Unit(30, 'microliter/second')
self.assertTrue(u1 < u2)
self.assertTrue(u2 > u1)
self.assertEqual(u1 + u2, Unit(50, 'microliter/second'))
self.assertEqual(u1 - u2, Unit(-10, 'microliter/second'))
def test_compound_units(self):
u1 = Unit(20, 'microliter/second')
u2 = Unit(30, 'microliter/second')
assert (u1 < u2)
assert (u2 > u1)
assert (u1 + u2 == Unit(50, 'microliter/second'))
assert (u1 - u2 == Unit(-10, 'microliter/second'))
def test_set_volume_unit_conv(self):
self.c.well(0).set_volume("200:nanoliter")
assert (self.c.well(0).volume == Unit(0.2, "microliter"))
self.c.well(1).set_volume(".1:milliliter")
assert (self.c.well(1).volume == Unit(100, "microliter"))
with pytest.raises(ValueError):
self.c.well(2).set_volume("1:milliliter")
def test_compound_units(self):
u1 = Unit(20, "microliter/second")
u2 = Unit(30, "microliter/second")
assert u1 < u2
assert u2 > u1
assert u1 + u2 == Unit(50, "microliter/second")
assert u1 - u2 == Unit(-10, "microliter/second")
def test_string_rounding(self):
# Ensure that string representation is rounded
assert (
str(Unit(0.1, "microliter") + Unit(0.2, "microliter")) == "0.3:microliter"
)
# Currently we round to 12 decimal places by default
assert str(Unit(0.1234567890123, "microliter")) == "0.123456789012:microliter"
assert str(Unit(0.1234567890126, "microliter")) == "0.123456789013:microliter"
def test_input_types(self):
u1 = Unit("20.1:microliter")
u2 = Unit(20.1, "microliter")
u3 = Unit(Decimal("20.1"), "microliter")
assert u1 == u2 == u3
assert isinstance(u1.magnitude, Decimal)
with pytest.raises(UnitValueError):
Unit(1j, "microliter")
def test_generates_liquid_handle_with_density(self):
self.p.transfer(self.flat.well(0),
self.flat.well(0),
"1:uL",
density=Unit(1.1, "mg/ml"))
inst = self.p.instructions[-1]
assert inst.op == "liquid_handle"
assert inst.data["locations"][0]["transports"][4]["density"] == Unit(
1.1, "mg/ml")
def test_updates_well_volume(self):
source = self.flat.well(0)
destination = self.flat.well(1)
source_volume = Unit(30, "uL")
volume = Unit(20, "uL")
self.p.transfer(source.set_volume(source_volume), destination, volume)
assert source.volume == source_volume - volume
assert destination.volume == volume
def test_comparison(self):
u1 = Unit(20, 'microliter')
u2 = Unit(30, 'microliter')
self.assertFalse(u1 == u2)
self.assertTrue(u1 == Unit(20, 'microliter'))
self.assertTrue(u1 != u2)
self.assertTrue(u1 < u2)
self.assertTrue(u1 <= u2)
self.assertFalse(u1 > u2)
self.assertTrue(u2 > u1)
def test_split_volume_transfer(self):
self.p.transfer(self.deep.well(0), self.deep.well(1), "2000:uL")
assert len(self.p.instructions) == 3
volumes = [
_.locations[1]["transports"][4]["volume"]
for _ in self.p.instructions
]
expected_volumes = [Unit(895, "uL"), Unit(895, "uL"), Unit(210, "uL")]
assert volumes == expected_volumes
def test_arithmetic(self):
u1 = Unit(20, 'microliter')
u2 = Unit(30, 'microliter')
assert (Unit(50, 'microliter') == u1 + u2)
assert (Unit(50, 'microliter') == u2 + u1)
assert (Unit(-10, 'microliter') == u1 - u2)
assert (Unit(10, 'microliter') == u2 - u1)
assert (Unit(600, 'microliter') == u2 * u1._magnitude)
assert (Unit(600, 'microliter') == u2._magnitude * u1)
assert (Unit(1.5, 'microliter') == u2 / u1._magnitude)
assert (Unit(1, 'dimensionless') == u2 // u1)
def test_dimensional_arithmetic(self):
u1 = Unit(200, "microliter")
u2 = Unit(3, "milliliter")
assert Unit(3200, "microliter") == u1 + u2
assert Unit(3.2, "milliliter") == u2 + u1
assert Unit(-2800, "microliter") == u1 - u2
assert Unit(2.8, "milliliter") == u2 - u1
assert Unit(0.6, "milliliter**2") == u2 * u1
assert Unit(600000, "microliter**2") == u1 * u2
assert Unit(15, "dimensionless") == u2 / u1
assert Unit(0.066666667, "dimensionless") == (u1 / u2).round(9)
def test_arithmetic(self):
u1 = Unit(20, "microliter")
u2 = Unit(30, "microliter")
assert Unit(50, "microliter") == u1 + u2
assert Unit(50, "microliter") == u2 + u1
assert Unit(-10, "microliter") == u1 - u2
assert Unit(10, "microliter") == u2 - u1
assert Unit(600, "microliter") == u2 * u1.magnitude
assert Unit(600, "microliter") == u2.magnitude * u1
assert Unit(1.5, "microliter") == u2 / u1.magnitude
assert Unit(1, "dimensionless") == u2 // u1
def test_dimensional_arithmetic(self):
u1 = Unit(200, 'microliter')
u2 = Unit(3, 'milliliter')
assert Unit(3200, 'microliter') == u1 + u2
assert Unit(3.2, 'milliliter') == u2 + u1
assert Unit(-2800, 'microliter') == u1 - u2
assert Unit(2.8, 'milliliter') == u2 - u1
assert Unit(0.6, 'milliliter**2') == u2 * u1
assert Unit(600000, 'microliter**2') == u1 * u2
assert Unit(15, 'dimensionless') == u2 / u1
assert Unit(0.066666667, 'dimensionless') == (u1 / u2).round(9)
def test_arithmetic(self):
u1 = Unit(20, 'microliter')
u2 = Unit(30, 'microliter')
self.assertEqual(Unit(50, 'microliter'), u1 + u2)
self.assertEqual(Unit(50, 'microliter'), u2 + u1)
self.assertEqual(Unit(-10, 'microliter'), u1 - u2)
self.assertEqual(Unit(10, 'microliter'), u2 - u1)
self.assertEqual(Unit(600, 'microliter'), u2 * u1.value)
self.assertEqual(Unit(1.5, 'microliter'), u2 / u1.value)
self.assertEqual(Unit(1, 'microliter'), u2 // u1)
def __init__(self, shortname, description):
"""
Parameters
----------
shortname : str
A short name for the solution. (e.g. 'buffer')
description:
A descriptive name for the solution (e.g. '20 mM Tris 50 mM NaCl')
"""
self.shortname = shortname
self.description = description
self.species = None
self.concentration = Unit(0.0, 'moles/liter')
self.uncertainty = Unit(0.0, 'moles/liter')
def test_comparison(self):
u1 = Unit(20, "microliter")
u2 = Unit(30, "microliter")
u3 = Unit(1, "milliliter")
assert u1 != u2
assert u1 == Unit(20, "microliter")
assert u1 != u2
assert u1 < u2
assert u1 <= u2
assert u1 <= u2
assert u2 > u1
assert u1 < u2
assert u2 >= u1
assert u3 > u1
assert u2 < u3
def test_comparison(self):
u1 = Unit(20, 'microliter')
u2 = Unit(30, 'microliter')
u3 = Unit(1, 'milliliter')
assert (u1 != u2)
assert (u1 == Unit(20, 'microliter'))
assert (u1 != u2)
assert (u1 < u2)
assert (u1 <= u2)
assert (u1 <= u2)
assert (u2 > u1)
assert (u1 < u2)
assert (u2 >= u1)
assert (u3 > u1)
assert (u2 < u3)
def sample_protocol(protocol, params):
dest_plate = params["destination_plate"]
wells_to_measure = []
for location in params["dye_locations"]:
protocol.transfer(params["dye"],
dest_plate.well(location["well_index"]),
location["volume"])
if location["volume"] != Unit(100, "microliter"):
protocol.transfer(params["water"],
dest_plate.well(location["well_index"]),
Unit(100, "microliter") - location["volume"],
mix_after=True)
wells_to_measure.append(location["well_index"])
protocol.absorbance(dest_plate, wells_to_measure, "475:nanometer", "test")
def provision_assay_plate(name, plate_type='4titude 4ti-0223', id=None):
"""
Provision a new assay plate.
Parameters
----------
name : str
The name of the container
plate_type : str, optional, default='4titude 4ti-0223'
The name of the plate type used to retrieve the `container_type` from library
id : str, optional, default=None
Unless `id` is specified, a unique container ID will be autogenerated.
"""
if id == None:
id = generate_uuid
# Define the container
container_type = container_types[plate_type]
container = Container(name="assay-plate",
id=id,
container_type=container_type)
# Initialize well properties for this container
for well in container.all_wells():
well.set_volume(Unit(0.0, 'microliters')) # well starts empty
return container
def test_single_transfer(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.transfer(c.well(0), c.well(1), "20:microliter")
self.assertEqual(Unit(20, "microliter"), c.well(1).volume)
self.assertEqual(None, c.well(0).volume)
self.assertTrue("transfer" in p.instructions[-1].groups[-1])
def measure_absorbance(self, record: paml.ActivityNodeExecution):
results = {}
call = record.call.lookup()
parameter_value_map = call.parameter_value_map()
wl = parameter_value_map["wavelength"]["value"]
wl_units = tyto.OM.get_term_by_uri(wl.unit)
samples = parameter_value_map["samples"]["value"]
wells = self.var_to_entity[samples]
measurements = parameter_value_map["measurements"]["value"]
# HACK extract contrainer from well group since we do not have it as input
container = wells[0].container
l.debug(f"measure_absorbance:")
l.debug(f" container: {container}")
l.debug(f" samples: {samples}")
l.debug(f" wavelength: {wl.value} {wl_units}")
self.protocol.spectrophotometry(
dataref=measurements,
obj=container,
groups=Spectrophotometry.builders.groups([
Spectrophotometry.builders.group(
"absorbance",
Spectrophotometry.builders.absorbance_mode_params(
wells=wells,
wavelength=Unit(wl.value, wl_units),
num_flashes=None,
settle_time=None,
read_position=None,
position_z=None))
]))
return results
def test_echo_max_vol(self):
from autoprotocol.protocol import Protocol
p = Protocol()
echo_w = p.ref("echo", None, "384-echo", discard=True).well(0)
echo_w.set_volume("135:microliter")
assert echo_w.volume == Unit(135, "microliter")
with pytest.raises(ValueError):
echo_w.set_volume("136:microliter")
def dummy_type():
return ContainerType(
name="dummy",
well_count=15,
well_depth_mm=None,
well_volume_ul=Unit(200, "microliter"),
well_coating=None,
sterile=False,
is_tube=False,
cover_types=[],
seal_types=None,
capabilities=[],
shortname="dummy",
col_count=5,
dead_volume_ul=Unit(15, "microliter"),
safe_min_volume_ul=Unit(30, "microliter")
)
def test_conversion(self):
assert (Unit(200, 'centimeter').to('meter') == Unit(2, 'meter'))
assert (Unit(20, 'microliter/second').to('liter/hour') == Unit(
0.072, 'liter / hour'))
# Due to floating point imprecision, use AlmostEqual as the test
# condition
assert almost_equal(
Unit(1000, 'microliter').to('milliliter'), Unit(1, 'milliliter'),
Unit(10**-12, 'milliliter'))
def test_updates_well_volume(self):
source_volume = Unit(30, "uL")
volume = Unit(20, "uL")
row_count = self.flat.container_type.row_count()
source_origin = self.flat.well(0)
source_wells = self.flat.wells_from(
source_origin, row_count,
columnwise=True).set_volume(source_volume)
destination_origin = self.flat.well(1)
destination_wells = self.flat.wells_from(destination_origin,
row_count,
columnwise=True)
self.p.transfer(source_origin,
destination_origin,
volume,
rows=row_count)
assert all(_.volume == source_volume - volume for _ in source_wells)
assert all(_.volume == volume for _ in destination_wells)
def test_multiple_sources(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(AssertionError):
p.consolidate(c.wells_from(0, 3), c.wells_from(2, 3),
"10:microliter")
p.consolidate(c.wells_from(0, 3), c.well(4), ["10:microliter"])
p.consolidate(c.wells_from(0, 3), c.well(4), "10:microliter")
self.assertEqual(Unit(30, "microliter"), c.well(4).volume)
self.assertEqual(
3, len(p.instructions[0].groups[0]["consolidate"]["from"]))
def dummy_echo():
return Container(
None,
ContainerType(
name="dummy",
well_count=384,
well_depth_mm=None,
well_volume_ul=Unit(65, "microliter"),
well_coating=None,
sterile=False,
is_tube=False,
cover_types=[],
seal_types=None,
capabilities=[],
shortname="dummy",
col_count=96,
dead_volume_ul=Unit(15, "microliter"),
safe_min_volume_ul=Unit(15, "microliter"),
true_max_vol_ul=Unit(135, "microliter"),
vendor="Labcyte"
)
)
def __init__(self, dmso_stock):
"""
Parameters
----------
dmso_stock : dict
The dictionary containing 'id', 'compound_name', 'compound mass (mg)', 'molecular weight', 'purity', 'solvent_mass'
"""
self.shortname = dmso_stock['id']
self.species = dmso_stock['compound name']
self.description = '10 mM ' + dmso_stock[
'compound name'] + ' DMSO stock'
dmso_density = Unit(1.1004, 'grams/milliliter')
mass_uncertainty = 0.01 # TODO: Calculate from balance precision
concentration = Unit(
dmso_stock['compound mass (mg)'],
'milligrams') * dmso_stock['purity'] / Unit(
dmso_stock['molecular weight'], 'grams/mole') / (
Unit(dmso_stock['solvent mass (g)'], 'grams') /
dmso_density) # mol/liter
self.concentration = concentration.to('moles/liter')
self.uncertainty = mass_uncertainty * self.concentration
self.buffer = DMSO
def test_units_match(self):
with pytest.raises(ValueError):
Unit(20, 'microliter') + Unit(30, 'second')
with pytest.raises(ValueError):
Unit(20, 'microliter') - Unit(30, 'second')
with pytest.raises(ValueError):
Unit(20, 'microliter') < Unit(30, 'second')
