Hi Oliver,

I have an idea for why this may not be working for you, but I'd rather 
respond to a question on StackOverflow 
(https://stackoverflow.com/questions/ask) tagged with the "rdflib" tag 
added (rdflib should autocomplete in the tags input), as this email list is 
for technical matters relating to the RDFLib software, not usage questions. 

I just checked that I am subscribed to email notifications for new [rdflib] 
questions (https://stackoverflow.com/questions/tagged/rdflib) on 
StackOverflow. If I don't respond to your question soon, feel free to email 
me directly to get on it. :)

Best,
Donny
On Friday, May 20, 2022 at 8:13:53 AM UTC-7 Olivier Inizan wrote:

> Hi there,
>
> I am trying to play with rdflib and a (my) user defined vocabulary (name: 
> ODE).
> To do that I have generated a class namespace/_ODE.py derived from 
> DefinedNamespace:
>   1 from rdflib.term import URIRef
>   2 from rdflib.namespace import DefinedNamespace, Namespace
>   3 
>   4 
>   5 class ODE(DefinedNamespace):
>   6     """          
>   7     DESCRIPTION_EDIT_ME_!
>   8 
>   9     Generated from: SOURCE_RDF_FILE_EDIT_ME_!
>  10     Date: 2022-05-02 08:38:55.619901
>  11     """              
>  12 
>  13     _fail = True
>  14 
>  15     Function: URIRef
>  16     Equation: URIRef
>  17     hasDerivative: URIRef
>  18     Polynomial: URIRef    
>  19     Ode: URIRef
>  20 
>  21     _NS = Namespace("ode#")
>  22 
>
> As all the new "classes" of the ODE vocabulary are a specialization of the 
> class "Seq" I have created the module rdflib/ode.py:
>
>   1 from rdflib import Seq
>   2 from rdflib.namespace import RDF,ODE,MATH
>   3 
>   4 __all__ = ["Function", "Equation","Polynomial","Ode"]
>   5 
>   6 
>   7 class Ode(Seq):
>   8     def __init__(self, graph, uri, seq=[], rtype="Ode"):
>   9         """Creates a Container
>  10 
>  11         :param graph: a Graph instance
>  12         :param uri: URI or Blank Node of the Container
>  13         :param seq: the elements of the Container
>  14         :param rtype: the type of Container, one of "Bag", "Seq" or 
> "Alt"
>  15         """
>  16 
>  17         self.graph = graph
>  18         self.uri = uri or BNode()
>  19         self._len = 0
>  20         self._rtype = rtype  # rdf:Bag or rdf:Seq or rdf:Alt
>  21 
>  22         self.append_multiple(seq)
>  23 
>  24         # adding triple corresponding to container type
>  25         self.graph.add((self.uri, RDF.type, ODE[self._rtype]))
>  26 
>  27 class Function(Ode):
>  28     def __init__(self, graph, uri, seq=[]):
>  29         Ode.__init__(self, graph, uri, seq, "Function")
>  30 
>  31 
>  32 class Equation(Ode):
>  33     def __init__(self, graph, uri, seq=[]):
>  34         Ode.__init__(self, graph, uri, seq, "Equation")
>  35 
>  36 class Polynomial(Ode):
>  37     def __init__(self, graph, uri, seq=[]):
>  38         Ode.__init__(self, graph, uri, seq, "Polynomial") 
>
> With these two classes I can generate a RDF file in a declarative way.
> For example we can create the Function c(t):
> 1  from rdflib import Graph, URIRef, RDF, BNode, RDFS, Literal, Seq, Bag, 
> Function, Equation, Times, Minus, Polynomial, Ode
> 2  from rdflib.namespace import ODE, MATH
> 3
> 4  # the time t 
> 5  t = BNode("t")
> 6  graph.add((t,RDFS.label,Literal("t")))
> 7
> 8  c_of_t_label = BNode("c")
> 9  graph.add((c_of_t_label,RDFS.label,Literal("c")))
> 10 c_of_t_bn = BNode("c_of_t")
> 11
> 12 Function(graph,c_of_t_bn,[c_of_t_label,t])
>
> And we obtain the following RDF:
> _:c rdfs:label "c" .
> _:t rdfs:label "t" .
> _:c_of_t a ode:Function ;
>     rdf:_1 _:c ;
>     rdf:_2 _:t .
>
> So far, so good. Now I want to execute a SPARQL query on this rdf to 
> retrieve the function.
>                                                                           
>                                                                             
>                    
> 1 import rdflib
> 2 
> 3 from rdflib import Graph, URIRef, RDF, BNode, RDFS, Literal, Seq, Bag, 
> Function, Equation, Times, Minus, Polynomial, Ode
> 4 from rdflib.namespace import ODE, MATH
> 5 
> 6 def main():
> 7     g = rdflib.Graph()
> 8     g.parse("ode_spe", format="ttl")
> 9     
> 10     
> 11     function = ODE.Function
> 12     
> 13     query_test= "SELECT ?e WHERE {?e rdf:type ode:Function . }"
> 14     qres = g.query(query_test)
> 15     
> 16     print (len(qres))
> 17 if __name__ == "__main__":
> 18     main()
>
> But I have no results.
> I probably do not do the right thing with ode:Function.
>
> I have two questions:
> - Is it the right way to add a user defined vocabulary ?
> - And what can I do to retrieve the function with a SPARQL query
>
> Thank for your help.
>
> Olivier
>

-- 
http://github.com/RDFLib
--- 
You received this message because you are subscribed to the Google Groups 
"rdflib-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to rdflib-dev+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/rdflib-dev/a8f751c5-00f0-4e95-ba2f-61710b60f69dn%40googlegroups.com.

Reply via email to