Merge pull request #46 from joshmoore/fix-45-labels

Link shapes (and their annotations)

Author: joshmoore

src/omero_rdf/__init__.py

@@ -387,6 +387,21 @@ def __call__(self, o: BlitzObjectWrapper) -> URIRef:
             data = encoder.encode(o)
             return self.handle(data)
 
+    def annotations(self, obj, objid):
+        """
+        Loop through all annotations and handle them individually.
+        """
+        if isinstance(obj, IObject):
+            # Not a wrapper object
+            for annotation in obj.linkedAnnotationList():
+                annid = self(annotation)
+                self.contains(objid, annid)
+        else:
+            for annotation in obj.listAnnotations(None):
+                obj._loadAnnotationLinks()
+                annid = self(annotation)
+                self.contains(objid, annid)
+
     def handle(self, data: Data) -> URIRef:
         """
         Parses the data object into RDF triples.
@@ -412,6 +427,15 @@ def handle(self, data: Data) -> URIRef:
 
         return _id
 
+    def contains(self, parent, child):
+        """
+        Use emit to generate isPartOf and hasPart triples
+
+        TODO: add an option to only choose one of the two directions.
+        """
+        self.emit((child, DCTERMS.isPartOf, parent))
+        self.emit((parent, DCTERMS.hasPart, child))
+
     def emit(self, triple: Triple):
         if self.formatter.streaming:
             print(self.formatter.serialize_triple(triple), file=self.filehandle)
@@ -623,68 +647,56 @@ def descend(
             scrid = handler(scr)
             for plate in scr.listChildren():
                 pltid = self.descend(gateway, plate._obj, handler)
-                handler.emit((pltid, DCTERMS.isPartOf, scrid))
-                handler.emit((scrid, DCTERMS.hasPart, pltid))
-            for annotation in scr.listAnnotations(None):
-                annid = handler(annotation)
-                handler.emit((annid, DCTERMS.isPartOf, scrid))
+                handler.contains(scrid, pltid)
+            handler.annotations(scr, scrid)
             return scrid
 
         elif isinstance(target, Plate):
             plt = self._lookup(gateway, "Plate", target.id)
             pltid = handler(plt)
-            for annotation in plt.listAnnotations(None):
-                annid = handler(annotation)
-                handler.emit((annid, DCTERMS.isPartOf, pltid))
+            handler.annotations(plt, pltid)
             for well in plt.listChildren():
                 wid = handler(well)  # No descend
-                handler.emit((wid, DCTERMS.isPartOf, pltid))
+                handler.contains(pltid, wid)
                 for idx in range(0, well.countWellSample()):
                     img = well.getImage(idx)
                     imgid = self.descend(gateway, img._obj, handler)
-                    handler.emit((imgid, DCTERMS.isPartOf, wid))
-                    handler.emit((wid, DCTERMS.hasPart, imgid))
+                    handler.contains(wid, imgid)
             return pltid
 
         elif isinstance(target, Project):
             prj = self._lookup(gateway, "Project", target.id)
             prjid = handler(prj)
-            for annotation in prj.listAnnotations(None):
-                annid = handler(annotation)
-                handler.emit((annid, DCTERMS.isPartOf, prjid))
+            handler.annotations(prj, prjid)
             for ds in prj.listChildren():
                 dsid = self.descend(gateway, ds._obj, handler)
-                handler.emit((dsid, DCTERMS.isPartOf, prjid))
-                handler.emit((prjid, DCTERMS.hasPart, dsid))
+                handler.contains(prjid, dsid)
             return prjid
 
         elif isinstance(target, Dataset):
             ds = self._lookup(gateway, "Dataset", target.id)
             dsid = handler(ds)
-            for annotation in ds.listAnnotations(None):
-                annid = handler(annotation)
-                handler.emit((annid, DCTERMS.isPartOf, dsid))
+            handler.annotations(ds, dsid)
             for img in ds.listChildren():
                 imgid = self.descend(gateway, img._obj, handler)
-                handler.emit((imgid, DCTERMS.isPartOf, dsid))
-                handler.emit((dsid, DCTERMS.hasPart, imgid))
+                handler.contains(dsid, imgid)
             return dsid
 
         elif isinstance(target, Image):
             img = self._lookup(gateway, "Image", target.id)
             imgid = handler(img)
             if img.getPrimaryPixels() is not None:
                 pixid = handler(img.getPrimaryPixels())
-                handler.emit((pixid, DCTERMS.isPartOf, imgid))
-                handler.emit((imgid, DCTERMS.hasPart, pixid))
-            for annotation in img.listAnnotations(None):
-                img._loadAnnotationLinks()
-                annid = handler(annotation)
-                handler.emit((annid, DCTERMS.isPartOf, imgid))
+                handler.contains(imgid, pixid)
+            handler.annotations(img, imgid)
             for roi in self._get_rois(gateway, img):
                 roiid = handler(roi)
-                handler.emit((roiid, DCTERMS.isPartOf, pixid))
-                handler.emit((pixid, DCTERMS.hasPart, roiid))
+                handler.annotations(roi, roiid)
+                handler.contains(pixid, roiid)
+                for shape in roi.iterateShapes():
+                    shapeid = handler(shape)
+                    handler.annotations(shape, shapeid)
+                    handler.contains(roiid, shapeid)
             return imgid
 
         else:

test/integration/clitest/test_rdf.py

@@ -21,9 +21,10 @@
 
 from omero.testlib.cli import CLITest
 from omero_rdf import RdfControl
-from omero.model import RoiI
+from omero.model import LabelI, RoiI, CommentAnnotationI
+from omero.rtypes import rstring
 
-from rdflib import Graph, Namespace, RDF
+from rdflib import Graph, Literal, Namespace, RDF
 from rdflib.namespace import DCTERMS
 
 
@@ -53,7 +54,17 @@ def test_rois(self, capfd):
         # Setup a test image with a roi
         pix = self.create_pixels()
         img = pix.image
+        roi_ann = CommentAnnotationI()
+        roi_ann.setTextValue(rstring("my roi annotation"))
         roi = RoiI()
+        roi.setDescription(rstring("please check me"))
+        roi.linkAnnotation(roi_ann)
+        label_ann = CommentAnnotationI()
+        label_ann.setTextValue(rstring("my label annotation"))
+        label = LabelI()
+        label.setTextValue(rstring("this is the label"))
+        label.linkAnnotation(label_ann)
+        roi.addShape(label)
         img.addRoi(roi)
         img = update.saveAndReturnObject(img)
 
@@ -68,11 +79,27 @@ def test_rois(self, capfd):
         g.parse(data=out, format="ttl")
 
         xml = Namespace("http://www.openmicroscopy.org/Schemas/OME/2016-06#")
-
+        self.assert_contained_type(g, xml.ROI, xml.Pixels)
+        for x in (
+            "my roi annotation",
+            "please check me",
+            "my label annotation",
+            "this is the label",
+        ):
+            self.assert_string_found(g, x)
+
+    def assert_contained_type(self, g, child_type, parent_type):
         found = False
         for s, p, o in g.triples((None, DCTERMS.isPartOf, None)):
-            print(s, p, o)
-            if (s, RDF.type, xml.ROI) in g and (o, RDF.type, xml.Pixels) in g:
+            if (s, RDF.type, child_type) in g and (o, RDF.type, parent_type) in g:
                 found = True
+                break
+        assert found, f"no link between {parent_type} and {child_type}:" + g.serialize()
 
-        assert found, "no link between pixels and ROI:" + g.serialize()
+    def assert_string_found(self, g, search_string):
+        found = False
+        search_literal = Literal(search_string)
+        for s, p, o in g.triples((None, None, search_literal)):
+            found = True
+            break
+        assert found, f"string not found '{search_string}':\n" + g.serialize()