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 runTest(self):
p1 = Protocol()
p2 = Protocol()
p1.spin("dummy_ref", "2000:rpm", "560:second")
self.assertEqual(len(p2.instructions), 0,
"incorrect number of instructions in empty protocol")
def test_single_well(self):
p = Protocol()
test_plate = p.ref("test", None, "96-flat", discard=True)
p.fluorescence(test_plate, test_plate.well(0),
excitation="587:nanometer", emission="610:nanometer",
dataref="test_reading")
self.assertTrue(isinstance(p.instructions[0].wells, list))
def runTest(self):
p1 = Protocol()
p2 = Protocol()
p1.spin("dummy_ref", "2000:rpm", "560:second")
self.assertEqual(len(p2.instructions), 0,
"incorrect number of instructions in empty protocol")
def test_duplicates_not_allowed(self):
p = Protocol()
p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(AssertionError):
p.ref("test", None, "96-flat", storage="cold_20")
self.assertTrue(p.refs["test"].opts["discard"])
self.assertFalse("where" in p.refs["test"].opts)
def test_flow(self):
"""
Desired Output:
1. Perform flow cytometry on well0 with the respective FSC and SSC channel parameters
"""
p = Protocol()
dataref = "test_ref"
well0 = p.ref("test_plate", None, "96-pcr",
discard=True).well(0)
FSC = {"voltage_range": {"low": "230:volt", "high": "280:volt"},
"area": True, "height": True, "weight": False}
SSC = {"voltage_range": {"low": "230:volt", "high": "280:volt"},
"area": True, "height": True, "weight": False}
channel0 = [FSC, SSC]
neg_controls = [{"well": well0, "volume": "100:microliter",
"captured_events": 5, "channel": channel0}]
samples = [{"well": well0,
"volume": "100:microliter", "captured_events": 9}]
p.flow_analyze(dataref, FSC, SSC, neg_controls,
samples)
pjsonString = json.dumps(p.as_dict(), indent=2)
pjson = json.loads(pjsonString)
parser_instance = english.AutoprotocolParser(pjson)
parser_instance.job_tree()
parsed_output = parser_instance.parsed_output
steps = parser_instance.object_list
forest = parser_instance.forest_list
self.assertEqual(
parsed_output, ["Perform flow cytometry on test_plate/0 with the respective FSC and SSC channel parameters"])
self.assertEqual(forest, [[1]])
def test_one_tip(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.transfer(c.wells_from(0, 2), c.wells_from(2, 2), "20:microliter",
one_tip=True)
self.assertEqual(c.well(2).volume, c.well(3).volume)
self.assertEqual(1, len(p.instructions[0].groups))
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 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 test_one_tip(self):
p = Protocol()
plateCount = 2
plateList = [p.ref("plate_%s_384" % str(x+1), None, "384-flat", discard=True) for x in range(plateCount)]
p.stamp(plateList[0], plateList[1], "330:microliter", one_tip=True)
self.assertEqual(len(p.instructions[0].groups[0]["transfer"]), 12)
self.assertEqual(len(p.instructions[0].groups), 1)
def test_one_source(self):
p = Protocol()
echo = p.ref("echo", None, "384-echo", discard=True)
dest = p.ref("dest", None, "384-flat", discard=True)
p.acoustic_transfer(echo.wells(0,1).set_volume("2:microliter"),
dest.wells(0,1,2,3), "1:microliter", one_source=True)
self.assertTrue(p.instructions[-1].data["groups"][0]["transfer"][-1]["from"] == echo.well(1))
self.assertTrue(p.instructions[-1].data["groups"][0]["transfer"][0]["from"] == echo.well(0))
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 test_all_container_types(self):
from autoprotocol.container_type import _CONTAINER_TYPES
from autoprotocol.protocol import Protocol
p = Protocol()
for k, v in _CONTAINER_TYPES.items():
p.ref(k, None, v.shortname, discard=True)
assert (len(p.refs) == len(_CONTAINER_TYPES))
def test_one_tip(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.transfer(c.wells_from(0, 2),
c.wells_from(2, 2),
"20:microliter",
one_tip=True)
self.assertEqual(c.well(2).volume, c.well(3).volume)
self.assertEqual(1, len(p.instructions[0].groups))
def test_all_container_types(self):
from autoprotocol.container_type import _CONTAINER_TYPES
from autoprotocol.protocol import Protocol
p = Protocol()
for k, v in _CONTAINER_TYPES.items():
p.ref(k, None, v.shortname, discard=True)
assert (len(p.refs) == len(_CONTAINER_TYPES))
def test_distribute_one_well(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.distribute(c.well(0).set_volume("20:microliter"),
c.well(1),
"5:microliter")
self.assertEqual(1, len(p.instructions))
self.assertEqual("distribute",
list(p.as_dict()["instructions"][0]["groups"][0].keys())[0])
self.assertTrue(5, c.well(1).volume.value)
self.assertTrue(15, c.well(0).volume.value)
def test_sequence_cover_instructions2(self):
p = Protocol()
cont1 = p.ref("c1", None, "96-pcr", storage="cold_4")
p.incubate(cont1, "ambient", duration="1:minute")
assert (p.instructions[0].op == "seal")
cont2 = p.ref("c2", None, "96-pcr", storage="cold_4")
p.incubate(cont2, "ambient", duration="1:minute", uncovered=True)
assert (p.instructions[-2].op == "incubate")
with pytest.raises(RuntimeError):
p.incubate(cont1, "cold_4", duration="1:minute", uncovered=True)
def test_distribute_multiple_wells(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.distribute(c.well(0).set_volume("20:microliter"),
c.wells_from(1,3),
"5:microliter")
self.assertEqual(1, len(p.instructions))
self.assertEqual("distribute",
p.as_dict()["instructions"][0]["groups"][0].keys()[0])
for w in c.wells_from(1,3):
self.assertTrue(5, w.volume.value)
self.assertTrue(5, c.well(0).volume.value)
def test_gt_750uL_wellgroup_transfer(self):
p = Protocol()
c = p.ref("test", None, "96-deep", discard=True)
p.transfer(
c.wells_from(0, 8, columnwise=True),
c.wells_from(1, 8, columnwise=True),
'1800:microliter'
)
self.assertEqual(
24,
len(p.instructions[0].groups)
)
def test_as_dict(self):
p = Protocol()
cont1 = p.ref("cont_1", None, "96-flat", discard=True)
well1 = WellGroup([cont1.well(0)])
comp = Compound("Daylight Canonical SMILES", "C1=NC2=NC=NC(=C2N1)N")
assert AttachCompounds(well1, [comp]).as_dict() == {
"type": "attach_compounds",
"data": {
"wells": well1,
"compounds": [comp]
},
}
def test_web_example(self):
p = Protocol()
bacterial_sample = p.ref("bacteria", None, "micro-1.5", discard=True)
test_plate = p.ref("test_plate", None, "96-flat", storage="cold_4")
p.dispense_full_plate(test_plate, "lb-broth-noAB", "50:microliter")
w = 0
amt = 1
while amt < 20:
p.transfer(bacterial_sample.well(
0), test_plate.well(w), "%d:microliter" % amt)
amt += 2
w += 1
pjsonString = json.dumps(p.as_dict(), indent=2)
pjson = json.loads(pjsonString)
parser_instance = english.AutoprotocolParser(pjson)
parser_instance.job_tree()
parsed_output = parser_instance.parsed_output
steps = parser_instance.object_list
forest = parser_instance.forest_list
self.assertEqual(forest, [[1], [2], [3], [4], [5], [
6], [7], [8], [9], [10], [11]])
def test_validate(self):
p = Protocol()
cont1 = p.ref("cont_1", None, "96-flat", discard=True)
well1 = WellGroup([cont1.well(0)])
comp = Compound("Daylight Canonical SMILES", "C1=NC2=NC=NC(=C2N1)N")
with pytest.raises(TypeError):
AttachCompounds(well1, comp)
with pytest.raises(TypeError):
AttachCompounds("foo", [comp])
with pytest.raises(TypeError):
AttachCompounds(well1, "C1=NC2=NC=NC(=C2N1)N")
with pytest.raises(CompoundError):
AttachCompounds(
well1, [Compound("Daylight Canonical SMILES", "InChI=xxx")])
def test_attach_compounds(self):
p = Protocol()
cont1 = p.ref("cont_1", None, "96-flat", discard=True)
well1 = cont1.well(0)
well2 = cont1.well(1)
wg1 = WellGroup([well1, well2])
comp1 = Compound("Daylight Canonical SMILES",
"CN1C=NC2=C1C(=O)N(C(=O)N2C)C")
comp2 = Compound("Daylight Canonical SMILES", "C1=NC2=NC=NC(=C2N1)N")
assert AttachCompounds(well1, [comp1]).compounds == [comp1]
assert AttachCompounds(well1, [comp1]).wells == well1
assert AttachCompounds(wg1, [comp1, comp2]).compounds == [comp1, comp2]
assert AttachCompounds(wg1, [comp1, comp2]).wells == wg1
def test_single_transfers(self):
p = Protocol()
plate_96_list = []
for plate_num in range(5):
plate_name = ("test_96_"+str(plate_num))
plate_96_list.append(p.ref(plate_name, None, "96-flat", discard=True))
plate_384_list = []
for plate_num in range(3):
plate_name = ("test_384_"+str(plate_num))
plate_384_list.append(p.ref(plate_name, None, "384-flat", discard=True))
with self.assertRaises(RuntimeError):
# Transfer 4 plates
for pl, q in zip(plate_96_list, [0, 1, 24, 26]):
p.stamp(pl, plate_384_list[0], "10:microliter", to_quad = q)
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 __init__(self, barcode, well_count, part_num):
"""
Initializes the class values and populates the
plate information (e.g. barcode, no of wells, part no.)
"""
self.barcode = barcode
self.well_count = well_count
self.part_num = part_num
# define the REFs elements
self.p = Protocol()
self.id = self.p.ref(self.barcode,
id=self.barcode,
cont_type="96-pcr",
storage=None,
discard=True)
self.plate_protocol()
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 test_unit_conversion(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(ValueError):
p.transfer(c.well(0), c.well(1), "1:liter")
p.transfer(c.well(0), c.well(1), "200:nanoliter")
self.assertTrue(str(p.instructions[0].groups[0]['transfer'][0]['volume']) == "0.2:microliter")
p.transfer(c.well(1), c.well(2), ".5:milliliter", new_group=True)
self.assertTrue(str(p.instructions[-1].groups[0]['transfer'][0]['volume']) == "500.0:microliter")
def test_unit_conversion(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(RuntimeError):
with self.assertRaises(ValueError):
p.distribute(c.well(0).set_volume("100:microliter"), c.well(1), ".0001:liter")
p.distribute(c.well(0).set_volume("100:microliter"), c.well(1), "200:nanoliter")
self.assertTrue(str(p.instructions[0].groups[0]["distribute"]["to"][0]["volume"]) == "0.2:microliter")
p.distribute(c.well(2).set_volume("100:microliter"), c.well(3), ".1:milliliter", new_group=True)
self.assertTrue(str(p.instructions[-1].groups[0]["distribute"]["to"][0]["volume"]) == "100.0:microliter")
class Plate(Protocol):
"""
Object class for working with assay and reagent
plates in the APmaker program. This object inherits
from the Protocol object defined in AutoProtocol.
"""
def __init__(self, barcode, well_count, part_num):
"""
Initializes the class values and populates the
plate information (e.g. barcode, no of wells, part no.)
"""
self.barcode = barcode
self.well_count = well_count
self.part_num = part_num
# define the REFs elements
self.p = Protocol()
self.id = self.p.ref(self.barcode,
id=self.barcode,
cont_type="96-pcr",
storage=None,
discard=True)
self.plate_protocol()
def plate_protocol(self):
"""
Method to define the protocol that will be applied
to the plate.
"""
# weigh the mass of the plate before dispensing
self.p.measure_mass(self.id, self.barcode + "_mass_before")
self.p.dispense_full_plate(self.id, "water", "100:microliter")
self.p.measure_mass(self.id, self.barcode + "_mass_after")
def generate_autoprotocol(instructions_dict):
p = Protocol()
part_ref_dict = {} # ref name: ref_object
# add destination plate to ref dict
moclo_dest_plate_name = 'MoCloDestinationPlate'
moclo_dest_plate_ref = p.ref(moclo_dest_plate_name,
cont_type="96-pcr",
discard=True)
part_ref_dict[moclo_dest_plate_name] = moclo_dest_plate_ref
# create refs
for num, part_name in instructions_dict['parts'].items():
part_ref = p.ref(part_name, cont_type="96-pcr", discard=True)
part_ref_dict[part_name] = part_ref
# create instructions
for x in range(0, len(instructions_dict['source_wells'])):
from_well = instructions_dict['source_wells'][x]
part_name = instructions_dict['parts'][
from_well] # get part name in that well
source_plate = part_ref_dict[part_name] # get ref object
volume = instructions_dict['volumes'][x] # get volume
volume_str = str(volume) + ':microliter'
to_well = instructions_dict['dest_wells'][
x] # get destination well num
p.transfer(source_plate.wells_from(from_well, 1),
moclo_dest_plate_ref.wells_from(to_well, 1), volume_str)
return p.as_dict()
def test_gt_110uL_transfer(self):
p = Protocol()
plateCount = 2
plateList = [p.ref("plate_%s_96" % str(x+1), None, "96-flat", discard=True) for x in range(plateCount)]
p.stamp(plateList[0], plateList[1], "300:microliter")
self.assertEqual(3, len(p.instructions[0].groups))
self.assertEqual(
Unit(110, 'microliter'),
p.instructions[0].groups[0]['transfer'][0]['volume']
)
self.assertEqual(
Unit(95, 'microliter'),
p.instructions[0].groups[1]['transfer'][0]['volume']
)
self.assertEqual(
Unit(95, 'microliter'),
p.instructions[0].groups[2]['transfer'][0]['volume']
)
def test_transfer_option_propagation(self):
p = Protocol()
c = p.ref("test", None, "96-deep", discard=True)
p.transfer(
c.well(0),
c.well(1),
"1800:microliter",
aspirate_source=aspirate_source(
depth("ll_bottom", distance=".004:meter")
)
)
self.assertEqual(
len(p.instructions[0].groups[0]['transfer'][0]),
len(p.instructions[0].groups[1]['transfer'][0])
)
self.assertEqual(
len(p.instructions[0].groups[0]['transfer'][0]),
len(p.instructions[0].groups[2]['transfer'][0])
)
def test_one_source(self):
p = Protocol()
plateCount = 2
plateList = [p.ref("plate_%s_384" % str(x+1), None, "384-flat", discard=True) for x in range(plateCount)]
with self.assertRaises(RuntimeError):
p.stamp(plateList[0].wells(list(range(4))), plateList[1].wells(list(range(12))), "30:microliter", shape={"rows": 8, "columns": 1}, one_source=True)
plateList[0].wells_from(0, 64, columnwise=True).set_volume("10:microliter")
with self.assertRaises(RuntimeError):
p.stamp(plateList[0].wells(list(range(4))), plateList[1].wells(list(range(12))), "30:microliter", shape={"rows": 8, "columns": 1}, one_source=True)
plateList[0].wells_from(0, 64, columnwise=True).set_volume("15:microliter")
p.stamp(plateList[0].wells(list(range(4))), plateList[1].wells(list(range(12))), "5:microliter", shape={"rows": 8, "columns": 1}, one_source=True)
self.assertEqual(len(p.instructions[0].groups), 12)
def test_get_wells(self):
p = Protocol()
cont1 = p.ref("cont1", None, "6-flat", discard=True)
cont2 = p.ref("cont2", None, "6-flat", discard=True)
example_data = {
"list": [cont1.well(0), cont1.well(1)],
"well": cont2,
"dict": {"key1": 1, "key2": "bar", "dict_well": cont1.well(2)},
"bar": [
{"key4": "value", "key5": {"well": cont1.well(3)}},
{"key4": "value", "key5": {"well_group": WellGroup([cont1.well(4)])}},
],
"duplicate": cont1.well(0),
"nest": [{"list": [{"more_nested": [{"wells": [cont1.well(5)]}]}]}],
}
inst = Instruction(op="test", data=example_data)
wells = set(cont1.all_wells().wells + cont2.all_wells().wells)
assert set(inst.get_wells(example_data)) == wells
def test_one_source(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(ValueError):
p.transfer(c.wells_from(0, 2),
c.wells_from(2, 2), "40:microliter", one_source=True)
with self.assertRaises(RuntimeError):
p.transfer(c.wells_from(0, 2).set_volume("1:microliter"),
c.wells_from(1, 5), "10:microliter", one_source=True)
p.transfer(c.wells_from(0, 2).set_volume("50:microliter"),
c.wells_from(2, 2), "40:microliter", one_source=True)
self.assertEqual(2, len(p.instructions[0].groups))
self.assertFalse(p.instructions[0].groups[0]["transfer"][0]["from"] == p.instructions[0].groups[1]["transfer"][0]["from"])
def test_info_wells_checker(self):
p = Protocol()
cont1 = p.ref("cont1", None, "6-flat", discard=True)
compd = Compound("Daylight Canonical SMILES", "CN1C=NC2=C1C(=O)N(C(=O)N2C)C")
example_data = {"objects": [cont1.well(0), cont1.well(1)], "some_int": 1}
instr = Instruction(
op="test_instruction",
data=example_data,
informatics=[AttachCompounds(cont1.well(0), [compd])],
)
avail_wells = instr.get_wells(instr.data)
with pytest.raises(ValueError):
instr.informatics[0].wells = None
instr._check_info_wells(instr.informatics[0], avail_wells)
with pytest.raises(TypeError):
instr.informatics[0].wells = "cont1/0"
instr._check_info_wells(instr.informatics[0], avail_wells)
with pytest.raises(ValueError):
instr.informatics[0].wells = cont1.well(10)
instr._check_info_wells(instr.informatics[0], avail_wells)
def runTest(self):
p = Protocol()
self.assertEqual(len(p.instructions), 0,
"should not be any instructions before appending to empty protocol")
p.append(Spin("dummy_ref", "100:meter/second^2", "60:second"))
self.assertEqual(len(p.instructions), 1,
"incorrect number of instructions after single instruction append")
self.assertEqual(p.instructions[0].op, "spin",
"incorrect instruction appended")
p.append([
Incubate("dummy_ref", "ambient", "30:second"),
Spin("dummy_ref", "2000:rpm", "120:second")
])
self.assertEqual(len(p.instructions), 3,
"incorrect number of instructions after appending instruction list")
self.assertEqual(p.instructions[1].op, "incubate",
"incorrect instruction order after list append")
self.assertEqual(p.instructions[2].op, "spin",
"incorrect instruction at end after list append.")
def test_gt_750uL_transfer(self):
p = Protocol()
c = p.ref("test", None, "96-deep", discard=True)
p.transfer(
c.well(0),
c.well(1),
"1800:microliter"
)
self.assertEqual(3, len(p.instructions[0].groups))
self.assertEqual(
Unit(750, 'microliter'),
p.instructions[0].groups[0]['transfer'][0]['volume']
)
self.assertEqual(
Unit(750, 'microliter'),
p.instructions[0].groups[1]['transfer'][0]['volume']
)
self.assertEqual(
Unit(300, 'microliter'),
p.instructions[0].groups[2]['transfer'][0]['volume']
)
def __init__(self,
protocol=Protocol(),
items=Items(),
db=SolutionDB(),
logger=init_logging(),
rprotocol=RProtocol()):
self.protocol = protocol
self.items = items
self.db = db
self.logger = logger
self.rprotocol = rprotocol
def test_duplicates_not_allowed(self):
p = Protocol()
p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(AssertionError):
p.ref("test", None, "96-flat", storage="cold_20")
self.assertTrue(p.refs["test"].opts["discard"])
self.assertFalse("where" in p.refs["test"].opts)
def runTest(self):
p = Protocol()
self.assertEqual(
len(p.instructions), 0,
"should not be any instructions before appending to empty protocol"
)
p.append(Spin("dummy_ref", "100:meter/second^2", "60:second"))
self.assertEqual(
len(p.instructions), 1,
"incorrect number of instructions after single instruction append")
self.assertEqual(p.instructions[0].op, "spin",
"incorrect instruction appended")
p.append([
Incubate("dummy_ref", "ambient", "30:second"),
Spin("dummy_ref", "2000:rpm", "120:second")
])
self.assertEqual(
len(p.instructions), 3,
"incorrect number of instructions after appending instruction list"
)
self.assertEqual(p.instructions[1].op, "incubate",
"incorrect instruction order after list append")
self.assertEqual(p.instructions[2].op, "spin",
"incorrect instruction at end after list append.")
def test_dispense_suite(self):
"""
Desired Output:
1. Dispense 100 microliters of water to the full plate of sample_plate5
2. Dispense corresponding amounts of water to 12 column(s) of sample_plate5
3. Dispense 50 microliters of reagent with resource ID rs17gmh5wafm5p to the full plate of sample_plate5
"""
p = Protocol()
sample_plate5 = p.ref("sample_plate5", None,
"96-flat", storage="warm_37")
p.dispense_full_plate(sample_plate5, "water", "100:microliter")
p.dispense(sample_plate5,
"water",
[{"column": 0, "volume": "10:microliter"},
{"column": 1, "volume": "20:microliter"},
{"column": 2, "volume": "30:microliter"},
{"column": 3, "volume": "40:microliter"},
{"column": 4, "volume": "50:microliter"},
{"column": 5, "volume": "60:microliter"},
{"column": 6, "volume": "70:microliter"},
{"column": 7, "volume": "80:microliter"},
{"column": 8, "volume": "90:microliter"},
{"column": 9, "volume": "100:microliter"},
{"column": 10, "volume": "110:microliter"},
{"column": 11, "volume": "120:microliter"}
])
p.dispense_full_plate(sample_plate5, "rs17gmh5wafm5p", "50:microliter", is_resource_id=True)
pjsonString = json.dumps(p.as_dict(), indent=2)
pjson = json.loads(pjsonString)
parser_instance = english.AutoprotocolParser(pjson)
parser_instance.job_tree()
parsed_output = parser_instance.parsed_output
forest = parser_instance.forest_list
self.assertEqual(
parsed_output, ["Dispense 100 microliters of water to the full plate of sample_plate5",
"Dispense corresponding amounts of water to 12 column(s) of sample_plate5",
"Dispense 50 microliters of resource with resource ID rs17gmh5wafm5p to the full plate of sample_plate5"])
self.assertEqual(forest, [[1, [2, [3]]]])
def test_outs(self):
p = Protocol()
self.assertFalse('outs' in p.as_dict())
plate = p.ref("plate", None, "96-pcr", discard=True)
plate.well(0).set_name("test_well")
self.assertTrue(plate.well(0).name == "test_well")
self.assertTrue(list(p.as_dict()['outs'].keys()) == ['plate'])
self.assertTrue(list(list(p.as_dict()['outs'].values())[0].keys()) == ['0'])
self.assertTrue(list(p.as_dict()['outs'].values())[0]['0'] == {'name': 'test_well'})
def test_one_source(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
with self.assertRaises(ValueError):
p.transfer(c.wells_from(0, 2),
c.wells_from(2, 2),
"40:microliter",
one_source=True)
with self.assertRaises(RuntimeError):
p.transfer(c.wells_from(0, 2).set_volume("1:microliter"),
c.wells_from(1, 5),
"10:microliter",
one_source=True)
p.transfer(c.wells_from(0, 2).set_volume("50:microliter"),
c.wells_from(2, 2),
"40:microliter",
one_source=True)
self.assertEqual(2, len(p.instructions[0].groups))
self.assertFalse(p.instructions[0].groups[0]["transfer"][0]["from"] ==
p.instructions[0].groups[1]["transfer"][0]["from"])
def test_informatics():
p = Protocol()
cont1 = p.ref("cont1", None, "6-flat", discard=True)
compd = Compound("Daylight Canonical SMILES", "CN1C=NC2=C1C(=O)N(C(=O)N2C)C")
example_data = {
"wells": [cont1.well(0), cont1.well(1)],
"some_int": 1,
}
example_informatics = [AttachCompounds(cont1.well(0), [compd])]
instr = Instruction(
op="test_instruction", data=example_data, informatics=example_informatics
)
assert isinstance(instr.informatics[0], AttachCompounds)
assert instr.informatics[0].compounds[0].value == "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
instr_multi = Instruction(
op="test_instruction",
data=example_data,
informatics=[
AttachCompounds(cont1.well(0), [compd]),
AttachCompounds(cont1.well(1), [compd]),
],
)
assert len(instr_multi.informatics) == 2
def test_illumina(self):
"""
Desired Output:
1. Illumina sequence wells test_plate6/0, test_plate6/1 with library size 34
"""
p = Protocol()
sample_wells6 = p.ref(
"test_plate6", None, "96-pcr", discard=True).wells_from(0, 8)
p.illuminaseq("PE", [{"object": sample_wells6[0], "library_concentration": 1.0},
{"object": sample_wells6[1], "library_concentration": 2}],
"nextseq", "mid", 'none', 34, "dataref")
pjsonString = json.dumps(p.as_dict(), indent=2)
pjson = json.loads(pjsonString)
parser_instance = english.AutoprotocolParser(pjson)
parser_instance.job_tree()
parsed_output = parser_instance.parsed_output
steps = parser_instance.object_list
forest = parser_instance.forest_list
self.assertEqual(
parsed_output, ["Illumina sequence wells test_plate6/0, test_plate6/1 with library size 34"])
self.assertEqual(forest, [[1]])
def test_distribute_one_well(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.distribute(
c.well(0).set_volume("20:microliter"), c.well(1), "5:microliter")
self.assertEqual(1, len(p.instructions))
self.assertEqual("distribute",
p.as_dict()["instructions"][0]["groups"][0].keys()[0])
self.assertTrue(5, c.well(1).volume.value)
self.assertTrue(15, c.well(0).volume.value)
def test_refifying_various(self):
p = Protocol()
# refify container
refs = {"plate": p.ref("test", None, "96-flat", "cold_20")}
self.assertEqual(p._refify(refs["plate"]), "test")
# refify dict
self.assertEqual(p._refify(refs), {"plate": "test"})
# refify Well
well = refs["plate"].well("A1")
self.assertEqual(p._refify(well), "test/0")
# refify WellGroup
wellgroup = refs["plate"].wells_from("A2", 3)
self.assertEqual(p._refify(wellgroup), ["test/1", "test/2", "test/3"])
# refify other
s = "randomstring"
i = 24
self.assertEqual("randomstring", p._refify(s))
self.assertEqual(24, p._refify(i))
def test_one_tip_variable_volume(self):
p = Protocol()
plateCount = 2
plateList = [p.ref("plate_%s_384" % str(x+1), None, "384-flat", discard=True) for x in range(plateCount)]
with self.assertRaises(RuntimeError):
p.stamp(WellGroup([plateList[0].well(0), plateList[0].well(1)]), WellGroup([plateList[1].well(0), plateList[1].well(1)]), ["20:microliter", "90:microliter"], one_tip=True)
p.stamp(WellGroup([plateList[0].well(0), plateList[0].well(1)]), WellGroup([plateList[1].well(0), plateList[1].well(1)]), ["20:microliter", "90:microliter"], mix_after=True, mix_vol="40:microliter", one_tip=True)
self.assertEqual(len(p.instructions[0].groups[0]["transfer"]), 2)
self.assertEqual(len(p.instructions[0].groups), 1)
def test_distribute_multiple_wells(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
p.distribute(
c.well(0).set_volume("20:microliter"), c.wells_from(1, 3),
"5:microliter")
self.assertEqual(1, len(p.instructions))
self.assertEqual(
"distribute",
list(p.as_dict()["instructions"][0]["groups"][0].keys())[0])
for w in c.wells_from(1, 3):
self.assertTrue(5, w.volume.value)
self.assertTrue(5, c.well(0).volume.value)
def test_refifying_various(self):
p = Protocol()
# refify container
refs = {"plate": p.ref("test", None, "96-flat", "cold_20")}
self.assertEqual(p._refify(refs["plate"]), "test")
# refify dict
self.assertEqual(p._refify(refs), {"plate": "test"})
# refify Well
well = refs["plate"].well("A1")
self.assertEqual(p._refify(well), "test/0")
# refify WellGroup
wellgroup = refs["plate"].wells_from("A2", 3)
self.assertEqual(p._refify(wellgroup), ["test/1", "test/2", "test/3"])
# refify other
s = "randomstring"
i = 24
self.assertEqual("randomstring", p._refify(s))
self.assertEqual(24, p._refify(i))
def test_fill_wells(self):
p = Protocol()
c = p.ref("test", None, "96-flat", discard=True)
srcs = c.wells_from(1, 2).set_volume("100:microliter")
dests = c.wells_from(7, 4)
p.distribute(srcs, dests, "30:microliter", allow_carryover=True)
self.assertEqual(2, len(p.instructions[0].groups))
#track source vols
self.assertEqual(10, c.well(1).volume.value)
self.assertEqual(70, c.well(2).volume.value)
# track dest vols
self.assertEqual(30, c.well(7).volume.value)
self.assertIs(None, c.well(6).volume)
#test distribute from Well to Well
p.distribute(
c.well("A1").set_volume("20:microliter"), c.well("A2"),
"5:microliter")
self.assertTrue("distribute" in p.instructions[-1].groups[-1])
import json
from autoprotocol.protocol import Protocol
from utils import ul
inv = {
'gblock_dna': 'ct18vs7cmjat2c', # my inventory
'te': 'rs17pwyc754v9t', # catalog; TE
}
p = Protocol()
#existing inventory
dna_sample = p.ref("gblock_dna",
id=inv['gblock_dna'],
cont_type="micro-1.5",
storage='cold_20')
#tubes are thawed before being placed into workcell
#Centrifuge the tube for 3-5 sec at a minimum of 3000 x g to pellet the material to the bottom of the tube.
p.spin(dna_sample, '3000:g', '5:second')
#Add 500uL TE (to reach 1 ng/uL)
p.provision(inv["te"], dna_sample.well(0), ul(500))
#Briefly vortex (here we have to use mix) and centrifuge
p.mix(dna_sample.well(0),
'480:microliter',
speed='480:microliter/second',
repetitions=10)
def test_slashes_not_allowed(self):
p = Protocol()
with self.assertRaises(AssertionError):
p.ref("test/bar", None, "96-flat", discard=True)
self.assertEqual(0, len(p.refs))
def setup(self):
self.p = Protocol()
self.flat = self.p.ref("flat", cont_type="96-flat", discard=True)
self.deep = self.p.ref("deep", cont_type="96-deep", discard=True)
class LiquidHandleTester(object):
@pytest.fixture(autouse=True)
def setup(self):
self.p = Protocol()
self.flat = self.p.ref("flat", cont_type="96-flat", discard=True)
self.deep = self.p.ref("deep", cont_type="96-deep", discard=True)
class TestProvision(object):
@pytest.fixture(autouse=True)
def setup(self):
# pylint: disable=attribute-defined-outside-init
self.p = Protocol()
# pylint: disable=attribute-defined-outside-init
self.w1 = (self.p.ref("w1", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
def test_provision_well_capacity(self):
self.p.provision("rs17gmh5wafm5p", self.w1, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"expected_provision.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_attempt_to_provision_more_than_well_capacity(self):
with pytest.raises(ValueError):
self.p.provision("rs17gmh5wafm5p", self.w1, "500:microliter")
def test_with_invalid_resource_id(self):
with pytest.raises(TypeError):
self.p.provision(100, self.w1, "50:microliter")
def test_with_destinations_count_not_same_as_volumes(self):
volumes = ["50:microliter", "20:microliter"]
with pytest.raises(RuntimeError):
self.p.provision("rs17gmh5wafm5p", self.w1, volumes)
def test_with_volume_above_max(self):
with pytest.raises(ValueError):
self.p.provision("rs17gmh5wafm5p", self.w1, "200:microliter")
def test_with_multiple_wells(self):
w2 = (self.p.ref("w2", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
w3 = (self.p.ref("w3", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
wells = [self.w1, w2, w3]
self.p.provision("rs17gmh5wafm5p", wells, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_multiple_wells.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_with_consecutive_repeated_wells(self):
wells = [self.w1, self.w1]
self.p.provision("rs17gmh5wafm5p", wells, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_with_consecutive_repeated_wells.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_with_repeated_wells_but_discontinuous(self):
w2 = (self.p.ref("w2", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
wells = [self.w1, w2, self.w1]
self.p.provision("rs17gmh5wafm5p", wells, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_with_repeated_wells_but_discontinuous.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_with_multiple_wells_with_different_cont_types(self):
self.p.refs.clear()
w1 = (self.p.ref("w1", None, cont_type="1-flat",
discard=True).well(0).set_volume("2:microliter"))
w2 = (self.p.ref("w2", None, cont_type="6-flat-tc",
discard=True).well(0).set_volume("2:microliter"))
wells = [w1, w2]
self.p.provision("rs17gmh5wafm5p", wells, "1500:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_multiple_wells_with_diff_cont_types.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_provision_with_covered_container(self):
self.p.refs.clear()
w1 = (self.p.ref("w1",
None,
cont_type="96-pcr",
discard=True,
cover="standard").well(0).set_volume("2:microliter"))
self.p.provision("rs17gmh5wafm5p", w1, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_with_cover.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_provision_with_sealed_container(self):
self.p.refs.clear()
w1 = (self.p.ref("w1",
None,
cont_type="96-pcr",
discard=True,
cover="foil").well(0).set_volume("2:microliter"))
self.p.provision("rs17gmh5wafm5p", w1, "50:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_with_seal.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_for_multiple_dispenses_of_resource_in_containers_larger_than_900ml(
self):
self.p.refs.clear()
w1 = (self.p.ref("w1", None, cont_type="micro-2.0",
discard=True).well(0).set_volume("2:microliter"))
self.p.provision("rs17gmh5wafm5p", w1, volumes="1500:microliter")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"split_provisions_by_volume.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_provision_well_with_mass(self):
self.p.provision("rs17gmh5wafm5p", self.w1, amounts="50:ug")
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_for_mass.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_provision_multiple_wells_with_diff_masses(self):
w2 = (self.p.ref("w2", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
self.p.provision("rs17gmh5wafm5p", [self.w1, w2], ["50:ug", "25:mg"])
actual_instruction_as_json = json.dumps(
self.p.as_dict()["instructions"], indent=2, sort_keys=True)
expected_instruction_as_json = TestUtils.read_json_file(
"provision_with_more_than_one_mass.json")
assert expected_instruction_as_json == actual_instruction_as_json
def test_provision_wells_with_amounts_of_varying_measurement_modes(self):
w2 = (self.p.ref("w2", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
with pytest.raises(ValueError):
self.p.provision("rs17gmh5wafm5p", [self.w1, w2],
["50:lb", "50:gallon"])
def test_provision_passing_both_volumes_and_amounts(self):
with pytest.raises(ValueError):
self.p.provision("rs17gmh5wafm5p", self.w1, "25:ul", "50:mg")
def test_provision_well_with_neither_mass_nor_volume(self):
with pytest.raises(ValueError):
self.p.provision("rs17gmh5wafm5p", self.w1)
def setup(self):
# pylint: disable=attribute-defined-outside-init
self.p = Protocol()
# pylint: disable=attribute-defined-outside-init
self.w1 = (self.p.ref("w1", None, cont_type="96-pcr",
discard=True).well(0).set_volume("2:microliter"))
