def get_annotations(self): #------------------------- """ Return all Annotations about the recording. :rtype: list of bsml:Annotations """ sparql = """PREFIX bsml: <%(bsml)s> PREFIX rdfs: <%(rdfs)s> PREFIX dct: <%(dct)s> PREFIX prv: <%(prv)s> PREFIX tl: <%(tl)s> select ?ann ?about ?stype ?comment ?tag ?created ?source ?tm ?start ?duration ?timeline where { ?ann a bsml:Annotation minus { [] prv:precededBy ?ann } { ?ann dct:subject ?about . ?about a ?stype . optional { ?ann rdfs:comment ?comment } optional { ?ann dct:created ?created } optional { ?ann bsml:tag ?tag } { ?ann dct:subject <%(subject)s> } union { ?about a bsml:Segment ; dct:source <%(subject)s> ; dct:source ?source ; bsml:time ?tm . ?tm tl:timeline ?timeline . { ?tm a bsml:Interval ; tl:start ?start ; tl:duration ?duration } union { ?tm a bsml:Instant ; tl:at ?start } } } }""" % dict(subject=self._rec_uri, bsml=BSML.prefix, rdfs=RDFS.prefix, dct=DCT.prefix, prv=PRV.prefix, tl=TL.prefix) anns = [[ str(a[0].uri), str(a[1].uri), str(a[2]), a[3].value, a[5].value, str(a[6].uri), str(a[7].uri), a[8].value, None if a[9] in ['', None] else a[9].value, str(a[10].uri) ] for a in self.query(sparql)] anns.sort(key=operator.itemgetter(7, 1, 0)) # start, about, uri annotations = [] for a in anns: ann = Annotation(a[0], about=a[1], comment=a[3], created=a[4]) if a[2] == str(BSML.Segment): time = TemporalEntity.create(a[6], a[7], a[8], timeline=a[9]) ann.about = Segment(a[1], source=a[5], time=time) annotations.append(ann) return annotations
def get_annotations(self, subject, graph_uri=None): #-------------------------------------------------- """ Return all Annotations about a subject. This is significantly faster (approx 15x) then getting a list of URIs (fast) and then creating Annotations (slow). Code could be used as a template for general abstract object creation based on PropertyMap and bypassing internal use of RDF -- instead map directly to and from SPARQL. :param subject: The URI of the subject. :param graph_uri: An optional URI of the graph to query. :rtype: list of bsml:Annotations """ anns = self.get_resources( BSML.Annotation, rvars= '?ann ?about ?stype ?comment ?tag ?created ?source ?tm ?start ?duration ?timeline', condition='''minus { [] prv:precededBy ?ann } { ?ann dct:subject ?about . ?about a ?stype . optional { ?ann rdfs:comment ?comment } optional { ?ann dct:created ?created } optional { ?ann bsml:tag ?tag } { ?ann dct:subject <%(subject)s> } union { ?about a bsml:Segment ; dct:source <%(subject)s> ; dct:source ?source ; bsml:time ?tm . ?tm tl:timeline ?timeline . { ?tm a bsml:Interval ; tl:start ?start ; tl:duration ?duration } union { ?tm a bsml:Instant ; tl:at ?start } } }''' % dict(subject=subject), prefixes=dict(bsml=BSML.prefix, dct=DCT.prefix, prv=PRV.prefix, tl=TL.prefix), graph=graph_uri, # order = '?start', ## Virtuoso doesn't correctly sort xsd:dayTimeDuration ) anns.sort(key=operator.itemgetter(9, 2, 1)) # start, about, uri annotations = [] for a in anns: ann = Annotation(a[1], about=a[2], comment=a[4], created=a[6]) if str(a[3]) == str(BSML.Segment): time = TemporalEntity.create( a[8], float(a[9]), duration=None if a[10] in ['', None] else float(a[10]), timeline=a[11]) ann.about = Segment(a[2], source=a[7], time=time) annotations.append(ann) return annotations
def get_annotations(self, subject, graph_uri=None): # -------------------------------------------------- """ Return all Annotations about a subject. This is significantly faster (approx 15x) then getting a list of URIs (fast) and then creating Annotations (slow). Code could be used as a template for general abstract object creation based on PropertyMap and bypassing internal use of RDF -- instead map directly to and from SPARQL. :param subject: The URI of the subject. :param graph_uri: An optional URI of the graph to query. :rtype: list of bsml:Annotations """ anns = self.get_resources( BSML.Annotation, rvars="?ann ?about ?stype ?comment ?tag ?created ?source ?tm ?start ?duration ?timeline", condition="""minus { [] prv:precededBy ?ann } { ?ann dct:subject ?about . ?about a ?stype . optional { ?ann rdfs:comment ?comment } optional { ?ann dct:created ?created } optional { ?ann bsml:tag ?tag } { ?ann dct:subject <%(subject)s> } union { ?about a bsml:Segment ; dct:source <%(subject)s> ; dct:source ?source ; bsml:time ?tm . ?tm tl:timeline ?timeline . { ?tm a bsml:Interval ; tl:start ?start ; tl:duration ?duration } union { ?tm a bsml:Instant ; tl:at ?start } } }""" % dict(subject=subject), prefixes=dict(bsml=BSML.prefix, dct=DCT.prefix, prv=PRV.prefix, tl=TL.prefix), graph=graph_uri, # order = '?start', ## Virtuoso doesn't correctly sort xsd:dayTimeDuration ) anns.sort(key=operator.itemgetter(9, 2, 1)) # start, about, uri annotations = [] for a in anns: ann = Annotation(a[1], about=a[2], comment=a[4], created=a[6]) if str(a[3]) == str(BSML.Segment): time = TemporalEntity.create( a[8], float(a[9]), duration=None if a[10] in ["", None] else float(a[10]), timeline=a[11] ) ann.about = Segment(a[2], source=a[7], time=time) annotations.append(ann) return annotations
def get_annotation(self, uri, graph_uri=None): #--------------------------------------------- """ Get an Annotation from the repository. :param uri: The URI of an Annotation. :param graph_uri: An optional URI of the graph to query. :rtype: :class:`~biosignalml.Annotation` """ # The following line works around a Virtuoso problem if graph_uri is None: graph_uri = self.get_graph_and_recording_uri(uri)[0] graph = self.get_resource_as_graph(uri, BSML.Annotation, graph_uri) ##### Put into Annotation/Segment.load_from_graph() ???? for sg in graph.get_objects(uri, DCT.subject): ## This could be improved... graph.append_graph( self.get_resource_as_graph(sg.uri, BSML.Segment, graph_uri)) for tm in graph.get_objects( sg.uri, BSML.time): ## This could be improved... graph.append_graph( self.get_resource_as_graph(tm.uri, BSML.Instant, graph_uri)) graph.append_graph( self.get_resource_as_graph(tm.uri, BSML.Interval, graph_uri)) return Annotation.create_from_graph(uri, graph)
def get_annotation(self, uri): # ----------------------------- """ Get an Annotation from its recording's graph. :param uri: The URI of an Annotation. :rtype: :class:`~biosignalml.Annotation` """ return Annotation.create_from_graph(uri, self)
def get_annotation(self, uri): #----------------------------- """ Get an Annotation from its recording's graph. :param uri: The URI of an Annotation. :rtype: :class:`~biosignalml.Annotation` """ return Annotation.create_from_graph(uri, self)
def post(self): #-------------- name = self.full_uri text = self.get_argument('annotation', '').strip() if self.get_argument('action') == 'Annotate' and text: repo = options.repository target = self.get_argument('target') recording = repo.get_recording(target, with_signals=False, open_dataset=False) ann = Annotation.Note(recording.make_uri(prefix='annotation'), target, text, creator='%s/user/%s' % (repo.uri, self.current_user) if self.current_user is not None else None) repo.extend_graph(recording.graph.uri, ann.metadata_as_string()) self._show_contents(name, False)
def get_annotation(self, uri, graph_uri=None): # --------------------------------------------- """ Get an Annotation from the repository. :param uri: The URI of an Annotation. :param graph_uri: An optional URI of the graph to query. :rtype: :class:`~biosignalml.Annotation` """ # The following line works around a Virtuoso problem if graph_uri is None: graph_uri = self.get_graph_and_recording_uri(uri)[0] graph = self.get_resource_as_graph(uri, BSML.Annotation, graph_uri) ##### Put into Annotation/Segment.load_from_graph() ???? for sg in graph.get_objects(uri, DCT.subject): ## This could be improved... graph.append_graph(self.get_resource_as_graph(sg.uri, BSML.Segment, graph_uri)) for tm in graph.get_objects(sg.uri, BSML.time): ## This could be improved... graph.append_graph(self.get_resource_as_graph(tm.uri, BSML.Instant, graph_uri)) graph.append_graph(self.get_resource_as_graph(tm.uri, BSML.Interval, graph_uri)) return Annotation.create_from_graph(uri, graph)
def get_annotations(self): # ------------------------- """ Return all Annotations about the recording. :rtype: list of bsml:Annotations """ sparql = """PREFIX bsml: <%(bsml)s> PREFIX rdfs: <%(rdfs)s> PREFIX dct: <%(dct)s> PREFIX prv: <%(prv)s> PREFIX tl: <%(tl)s> select ?ann ?about ?stype ?comment ?tag ?created ?source ?tm ?start ?duration ?timeline where { ?ann a bsml:Annotation minus { [] prv:precededBy ?ann } { ?ann dct:subject ?about . ?about a ?stype . optional { ?ann rdfs:comment ?comment } optional { ?ann dct:created ?created } optional { ?ann bsml:tag ?tag } { ?ann dct:subject <%(subject)s> } union { ?about a bsml:Segment ; dct:source <%(subject)s> ; dct:source ?source ; bsml:time ?tm . ?tm tl:timeline ?timeline . { ?tm a bsml:Interval ; tl:start ?start ; tl:duration ?duration } union { ?tm a bsml:Instant ; tl:at ?start } } } }""" % dict( subject=self._rec_uri, bsml=BSML.prefix, rdfs=RDFS.prefix, dct=DCT.prefix, prv=PRV.prefix, tl=TL.prefix ) anns = [ [ str(a[0].uri), str(a[1].uri), str(a[2]), a[3].value, a[5].value, str(a[6].uri), str(a[7].uri), a[8].value, None if a[9] in ["", None] else a[9].value, str(a[10].uri), ] for a in self.query(sparql) ] anns.sort(key=operator.itemgetter(7, 1, 0)) # start, about, uri annotations = [] for a in anns: ann = Annotation(a[0], about=a[1], comment=a[3], created=a[4]) if a[2] == str(BSML.Segment): time = TemporalEntity.create(a[6], a[7], a[8], timeline=a[9]) ann.about = Segment(a[1], source=a[5], time=time) annotations.append(ann) return annotations
r.save_metadata_to_graph(g) s = MyRecording.create_from_graph('http://example.org/uri1', g) assert(r.metadata_as_string(rdf.Format.TURTLE) == s.metadata_as_string(rdf.Format.TURTLE)) s.comment='From graph' user = '******' a1 = 'http://example.org/annotation/1' a2 = 'http://example.org/annotation/2' a3 = 'http://example.org/annotation/3' t1 = 'http://example.org/onto#tag1' t2 = 'http://example.org/onto#tag2' t3 = 'http://example.org/onto#tag3' a = Annotation.Note(a1, s.uri, user, 'A test recording...') b = Annotation.Tag(a2, s.uri, user, t1) c = Annotation(a3, s.uri, user, tags=[t2, t3], text='Multiple tags') #print a.metadata_as_string(rdf.Format.TURTLE) #print b.metadata_as_string(rdf.Format.TURTLE) #print c.metadata_as_string(rdf.Format.TURTLE) c.save_metadata_to_graph(g) d = Annotation.create_from_graph(a3, g) assert(c.metadata_as_string(rdf.Format.TURTLE) == d.metadata_as_string(rdf.Format.TURTLE)) s.metadata['zz'] = [ a, b, c ] print s.metadata_as_string(rdf.Format.TURTLE)