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)