def test_add_entry_from_includes_in_dict(self):
dataset = AnnotatedDataset()
image1 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(image1)
image2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset._add_entry_from(image2)
self.assertTrue(dataset.contains_image(image2.info))
def test_does_update_with_if_same_well(self):
well = AnnotatedWellFolder()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
well.update_with(labeled_f0)
labeled_fm_2 = AnnotatedImage(INFO_FM_2, '1-cell')
well.update_with(labeled_fm_2)
self.assertEqual(len(well), 2)
def test_add_entry_from_includes_in_dict(self):
slide = AnnotatedSlideFolder()
image1 = AnnotatedImage(INFO_F0, '1-cell')
slide.update_with(image1)
image2 = AnnotatedImage(INFO_F0_2, '1-cell')
slide._add_entry_from(image2)
self.assertTrue(slide.contains_image(image2.info))
def test_does_update_with_if_same_focus(self):
focus = AnnotatedFocusFolder()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
focus.update_with(labeled_f0)
labeled_f0_2 = AnnotatedImage(INFO_F0_2, '1-cell')
focus.update_with(labeled_f0_2)
self.assertEqual(len(focus), 2)
def test_collate_annotations_with_list_and_scalar(self):
truth = [1, 2, 3]
one_and_two = AnnotatedImage(INFO_F0, truth[:2])
three = AnnotatedImage(INFO_F0, truth[2])
collated = one_and_two.collate_annotations_with(three)
self.assertEqual(collated.annotation, truth)
def test_collate_annotations_with_when_images_with_scalar_data(self):
truth = [1, 2]
one = AnnotatedImage(INFO_F0, truth[0])
two = AnnotatedImage(INFO_F0, truth[1])
collated = one.collate_annotations_with(two)
self.assertEqual(collated.annotation, truth)
def test_add_entry_from_includes_in_dict(self):
well = AnnotatedWellFolder()
image1 = AnnotatedImage(INFO_F0, '1-cell')
well.update_with(image1)
image2 = AnnotatedImage(INFO_F0_2, '1-cell')
well._add_entry_from(image2)
self.assertTrue(well.contains_image(image2.info))
def test_is_image_in_focus_when_does_contain(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
focus = AnnotatedFocusFolder.create_from(labeled1)
focus.update_with(labeled2)
self.assertTrue(focus.contains_image(labeled1.info))
self.assertTrue(focus.contains_image(labeled2.info))
def test_remove_recursively_when_image_is_not_in_wellfolder(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
well = AnnotatedWellFolder.create_from(labeled1)
well.update_with(labeled2)
labeled_notin = AnnotatedImage(INFO_FP, '1-cell')
self.assertRaises(ValueError, well.remove, labeled_notin)
def test_is_image_in_focus_when_does_contain(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset = AnnotatedDataset.create_from(labeled1)
dataset.update_with(labeled2)
self.assertTrue(dataset.contains_image(labeled1.info))
self.assertTrue(dataset.contains_image(labeled2.info))
def test_labeledimage_pack_for_json_pretty(self):
labeled = AnnotatedImage(INFO_F0, '1-cell')
packed_true = labeled.pack_for_json(pretty=True)
packed_false = labeled.pack_for_json(pretty=False)
# truth = {INFO_F0.image_number: '1-cell'}
truth = '1-cell'
self.assertEqual(packed_true, truth)
self.assertEqual(packed_false, truth)
def test_update_with_if_different_slide(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
labeled_fp = AnnotatedImage(INFO_FP, '1-cell')
dataset = AnnotatedDataset()
dataset.update_with(labeled_f0)
dataset.update_with(labeled_fp)
self.assertEqual(len(dataset), 2)
def test_does_update_with_if_same_focus(self):
dataset = AnnotatedDataset()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(labeled_f0)
labeled_f0_2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset.update_with(labeled_f0_2)
# Then the length should be 1, since it should update the same
# dictionary!
self.assertEqual(len(dataset), 1)
def test_does_update_with_if_same_focus(self):
slide = AnnotatedSlideFolder()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
slide.update_with(labeled_f0)
labeled_f0_2 = AnnotatedImage(INFO_F0_2, '1-cell')
slide.update_with(labeled_f0_2)
# Then the length should be 1, since it should update the same
# dictionary!
self.assertEqual(len(slide), 1)
def test_remove_when_image_is_in_focusfolder(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
focus = AnnotatedFocusFolder.create_from(labeled1)
focus.update_with(labeled2)
focus.remove(labeled1)
self.assertTrue(labeled1 not in focus)
self.assertGreater(len(focus), 0)
def test_nequals_when_not_equal(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
focus_v0 = AnnotatedFocusFolder()
focus_v0.update_with(labeled_f0)
labeled_fp = AnnotatedImage(INFO_FP, '1-cell')
focus_v1 = AnnotatedFocusFolder()
focus_v1.update_with(labeled_fp)
self.assertNotEqual(focus_v0, focus_v1)
def test_collate_wells(self):
label = AnnotatedImage(INFO_F0, '1-cell')
data = AnnotatedImage(label.info, [0, 1, 2])
well_labeled = AnnotatedWellFolder.create_from(label)
well_data = AnnotatedWellFolder.create_from(data)
collated = well_labeled.collate_annotations_with(well_data)
well_labeled.update_with(data)
self.assertEqual(well_labeled, collated)
def test_iterate_over_images(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
well = AnnotatedWellFolder.create_from(labeled1)
well.update_with(labeled2)
images = [i for i in well.iterate_over_images()]
self.assertEqual(len(images), 2)
self.assertIn(labeled1, images)
self.assertIn(labeled2, images)
def test_collate_focuses_on_different_image_returns_correct_type(self):
label = '1-cell'
datum = [1, 2, 3]
image_labeled = AnnotatedImage(INFO_F0, label)
different_datum = AnnotatedImage(INFO_F0_2, datum)
focus_labeled = AnnotatedFocusFolder.create_from(image_labeled)
focus_datum = AnnotatedFocusFolder.create_from(different_datum)
collated = focus_labeled.collate_annotations_with(focus_datum)
self.assertIsInstance(collated, AnnotatedFocusFolder)
def test_iter(self):
image_f0 = AnnotatedImage(INFO_F0, '1-cell')
image_fm = AnnotatedImage(INFO_FM, '1-cell')
image_fp = AnnotatedImage(INFO_FP, '1-cell')
dataset = AnnotatedDataset.create_from(image_f0)
dataset.update_with(image_fm)
dataset.update_with(image_fp)
entries_manual = [v for v in dataset._dict.values()]
entries_iter = [v for v in dataset]
ok = [m == i for m, i in zip(entries_manual, entries_iter)]
self.assertTrue(all(ok))
def test_remove_recursively_when_image_is_in_wellfolder(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
well = AnnotatedWellFolder.create_from(labeled1)
well.update_with(labeled2)
well.remove(labeled1, recursive=True)
# There should still be 1 focus:
self.assertEqual(len(well), 1)
# But the image should not be in the focus folder:
focus = [i for i in well][0]
self.assertTrue(labeled1 not in focus)
def test_collate_focuses_on_different_image_is_length_0(self):
label = '1-cell'
datum = [1, 2, 3]
image_labeled = AnnotatedImage(INFO_F0, label)
different_datum = AnnotatedImage(INFO_F0_2, datum)
focus_labeled = AnnotatedFocusFolder.create_from(image_labeled)
focus_datum = AnnotatedFocusFolder.create_from(different_datum)
collated = focus_labeled.collate_annotations_with(focus_datum)
# Since these two are different images, neither is present in both,
# so the length should be 0:
self.assertEqual(len(collated), 0)
def test_collate_focuses_raises_error_when_different_folders(self):
label = '1-cell'
datum = [1, 2, 3]
image_labeled = AnnotatedImage(INFO_F0, label)
different_datum = AnnotatedImage(INFO_FP, datum)
focus_0 = AnnotatedFocusFolder.create_from(image_labeled)
focus_plus = AnnotatedFocusFolder.create_from(different_datum)
self.assertRaises(
ValueError,
focus_0.collate_annotations_with,
focus_plus)
def test_collate_focuses_on_same_image_returns_correct_value(self):
label = '1-cell'
datum = [1, 2, 3]
image_labeled = AnnotatedImage(INFO_F0, label)
image_datum = AnnotatedImage(INFO_F0, datum)
focus_labeled = AnnotatedFocusFolder.create_from(image_labeled)
focus_datum = AnnotatedFocusFolder.create_from(image_datum)
collated_focus = focus_labeled.collate_annotations_with(focus_datum)
collated_value = collated_focus[collated_focus.keys()[0]].annotation
truth = [label] + datum
self.assertEqual(collated_value, truth)
def test_getitem(self):
slide = AnnotatedSlideFolder()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
slide.update_with(labeled_f0)
gotten = slide[labeled_f0.info.well]
self.assertIs(type(gotten), AnnotatedWellFolder)
def test_getitem(self):
well = AnnotatedWellFolder()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
well.update_with(labeled_f0)
gotten = well[labeled_f0.info.focus]
self.assertIs(type(gotten), AnnotatedFocusFolder)
def test_getitem(self):
dataset = AnnotatedDataset()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(labeled_f0)
gotten = dataset[labeled_f0.info.slide]
self.assertIs(type(gotten), AnnotatedSlideFolder)
def test_copy_is_deep(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
copied = dataset.copy()
key = dataset.keys()[0]
self.assertTrue(dataset[key] is not copied[key])
def test_keys(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
keys = dataset.keys()
truth = list(dataset._dict.keys())
self.assertEqual(keys, truth)
self.assertEqual(type(keys), list)
def test_values(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
values = dataset.values()
truth = list(dataset._dict.values())
self.assertEqual(values, truth)
self.assertEqual(type(values), list)
