def _load_container_object_from_db(db, container_name: str):
db_data = db_queries.get_container_by_name(db, container_name)
if not db_data:
raise ValueError(
"No container with name {} found in Containers database".format(
container_name))
container_type, *rel_coords = db_data
wells = db_queries.get_wells_by_container_name(db, container_name)
if not wells:
raise ResourceWarning(
"No wells for container {} found in ContainerWells database".
format(container_name))
if container_name in SUPPORTED_MODULES:
container = Module()
else:
container = Container()
container.properties['type'] = container_type
container._coordinates = Vector(rel_coords)
log.debug("Loading {} with coords {}".format(rel_coords, container_type))
for well in wells:
container.add(*_load_well_object_from_db(db, well))
return container
def generate_plate(wells, cols, spacing, offset, radius):
c = Container()
for i in range(0, wells):
well = Well(properties={'radius': radius})
row, col = divmod(i, cols)
name = chr(row + ord('A')) + str(1 + col)
coordinates = (col * spacing[0] + offset[0],
row * spacing[1] + offset[1], 0)
c.add(well, name, coordinates)
return c
def generate_deck(self):
deck = Deck()
slot = Slot()
deck.add(slot, 'A1', (5, 10, 0))
c = Container()
red = Well(properties={'radius': 5})
blue = Well(properties={'radius': 5})
c.add(red, "Red", (5, 5, 0))
c.add(blue, "Blue", (15, 5, 0))
slot.add(c, 'tube_rack')
return deck
def test_get_name(self):
deck = Deck()
slot = Slot()
c = Container()
deck.add(slot, 'A1', (0, 0, 0))
red = Well(properties={'radius': 5})
blue = Well(properties={'radius': 5})
c.add(red, "Red", (0, 0, 0))
c.add(blue, "Blue", (10, 0, 0))
slot.add(c)
self.assertEqual(red.get_name(), 'Red')
def json_to_labware(json_defn: dict) -> Container:
container_data = json_defn.copy()
container = Container()
container._coordinates = Vector(0, 0, 0)
wells = container_data.get('wells')
for well_name, json_well in wells.items():
well, coordinates = _json_to_well(json_well)
container.add(well, well_name, coordinates)
container.ordering = json_defn['ordering']
return container
def create_container_instance(name,
grid,
spacing,
diameter,
depth,
volume=0,
slot=None,
label=None,
Transposed=False):
from opentrons import robot
from opentrons.containers.placeable import Container, Well
if slot is None:
raise RuntimeError('"slot" argument is required.')
if label is None:
label = name
columns, rows = grid
col_spacing, row_spacing = spacing
custom_container = Container()
well_properties = {
'type': 'custom',
'diameter': diameter,
'height': depth,
'total-liquid-volume': volume
}
for r in range(rows):
for c in range(columns):
well = Well(properties=well_properties)
well_name = chr(c + ord('A')) + str(1 + r)
if Transposed:
coordinates = (r * col_spacing, c * row_spacing, 0)
else:
coordinates = (c * col_spacing, r * row_spacing, 0)
custom_container.add(well, well_name, coordinates)
# if a container is added to Deck AFTER a Pipette, the Pipette's
# Calibrator must update to include all children of Deck
for _, instr in robot.get_instruments():
if hasattr(instr, 'update_calibrator'):
instr.update_calibrator()
custom_container.properties['type'] = name
custom_container.get_name = lambda: label
# add to robot deck
robot.deck[slot].add(custom_container, label)
return custom_container
def generate_plate(wells, cols, spacing, offset, radius, height=0):
c = Container()
c.ordering = []
n_rows = int(wells / cols)
for i in range(n_rows):
c.ordering.append([])
for i in range(0, wells):
well = Well(properties={'radius': radius, 'height': height})
row, col = divmod(i, cols)
name = chr(col + ord('A')) + str(1 + row)
c.ordering[row].append(name)
coordinates = (col * spacing[0] + offset[0],
row * spacing[1] + offset[1],
0)
c.add(well, name, coordinates)
return c
def create(name, grid, spacing, diameter, depth, volume=0):
columns, rows = grid
col_spacing, row_spacing = spacing
custom_container = Container()
properties = {
'type': 'custom',
'diameter': diameter,
'height': depth,
'total-liquid-volume': volume
}
for r in range(rows):
for c in range(columns):
well = Well(properties=properties)
well_name = chr(c + ord('A')) + str(1 + r)
coordinates = (c * col_spacing, r * row_spacing, 0)
custom_container.add(well, well_name, coordinates)
json_container = container_to_json(custom_container, name)
save_custom_container(json_container)
persisted_containers.load_all_persisted_containers_from_disk()
def create(name, grid, spacing, diameter, depth, volume=0):
"""
Creates a labware definition based on a rectangular gird, depth, diameter,
and spacing. Note that this function can only create labware with regularly
spaced wells in a rectangular format, of equal height, depth, and radius.
Irregular labware defintions will have to be made in other ways or modified
using a regular definition as a starting point. Also, upon creation a
definition always has its lower-left well at (0, 0, 0), such that this
labware _must_ be calibrated before use.
:param name: the name of the labware to be used with `labware.load`
:param grid: a 2-tuple of integers representing (<n_columns>, <n_rows>)
:param spacing: a 2-tuple of floats representing
(<col_spacing, <row_spacing)
:param diameter: a float representing the internal diameter of each well
:param depth: a float representing the distance from the top of each well
to the internal bottom of the same well
:param volume: [optional] the maximum volume of each well
:return: the labware object created by this function
"""
columns, rows = grid
col_spacing, row_spacing = spacing
custom_container = Container()
properties = {
'type': 'custom',
'diameter': diameter,
'height': depth,
'total-liquid-volume': volume
}
for r in range(rows):
for c in range(columns):
well = Well(properties=properties)
well_name = chr(r + ord('A')) + str(1 + c)
coordinates = (c * col_spacing, (rows - r - 1) * row_spacing, 0)
custom_container.add(well, well_name, coordinates)
database.save_new_container(custom_container, name)
return database.load_container(name)
def create_container_obj_from_dict(container_data: dict) -> Container:
"""
Example input:
container data for a "24-plate":
{
"origin-offset":{
"x":13.3,
"y":17.5
},
"locations":{
"A1":{
"x":0.0,
"total-liquid-volume":3400,
"y":0.0,
"depth":16.2,
"z":0,
"diameter":15.62
},
"A2":{
"x":0.0,
"total-liquid-volume":3400,
"y":19.3,
"depth":16.2,
"z":0,
"diameter":15.62
}
Exampl input #2:
"trough-12row":
{
"locations":{
"A1":{
"x":0,
"y":0,
"z":0,
"depth":40,
"length":8,
"width":70,
"total-liquid-volume":22000
},
"A2":{
"x":0,
"y":9,
"z":0,
"depth":40,
"length":8,
"width":70,
"total-liquid-volume":22000
},
"A3":{
"x":0,
"y":18,
"z":0,
"depth":40,
"length":8,
"width":70,
"total-liquid-volume":22000
}
"""
container_data = copy.deepcopy(container_data)
origin_offset_x = container_data.get('origin-offset', {}).get('x') or 0
origin_offset_y = container_data.get('origin-offset', {}).get('y') or 0
container = Container()
locations = container_data.get('locations')
for well_name, well_properties in locations.items():
x = well_properties.pop('x')
y = well_properties.pop('y')
z = well_properties.pop('z')
# assert 'depth' in well_properties
# assert 'diameter' in well_properties
# assert 'length' in well_properties
# assert 'width' in well_properties
# assert 'total-liquid-volume' in well_properties
assert isinstance(x, numbers.Number)
assert isinstance(y, numbers.Number)
assert isinstance(z, numbers.Number)
well = Well(properties=well_properties)
# subtract half the size, because
# Placeable assigns X-Y to bottom-left corner, but
# persisted container files assign X-Y to center of each Well
x -= (well.x_size() / 2)
y -= (well.y_size() / 2)
well_coordinates = (x + origin_offset_x, y + origin_offset_y, z)
container.add(well, well_name, well_coordinates)
return container