01ib5NSrSSKJr SSKJr SSKJrJrJr S/r "SS5r g)a The [`Resource`][rdflib.resource.Resource] class wraps a [`Graph`][rdflib.graph.Graph] and a resource reference (i.e. a [`URIRef`][rdflib.term.URIRef] or [`BNode`][rdflib.term.BNode]) to support a resource-oriented way of working with a graph. It contains methods directly corresponding to those methods of the Graph interface that relate to reading and writing data. The difference is that a Resource also binds a resource identifier, making it possible to work without tracking both the graph and a current subject. This makes for a "resource oriented" style, as compared to the triple orientation of the Graph API. Resulting generators are also wrapped so that any resource reference values ([`URIRef`][rdflib.term.URIRef] and [`BNode`][rdflib.term.BNode]) are in turn wrapped as Resources. (Note that this behaviour differs from the corresponding methods in [`Graph`][rdflib.graph.Graph], where no such conversion takes place.) ## Basic Usage Scenario Start by importing things we need and define some namespaces: ```python >>> from rdflib import * >>> FOAF = Namespace("http://xmlns.com/foaf/0.1/") >>> CV = Namespace("http://purl.org/captsolo/resume-rdf/0.2/cv#") ``` Load some RDF data: ```python >>> graph = Graph().parse(format='n3', data=''' ... @prefix rdfs: . ... @prefix xsd: . ... @prefix foaf: . ... @prefix cv: . ... ... @base . ... ... a foaf:Person; ... rdfs:comment "Just a Python & RDF hacker."@en; ... foaf:depiction ; ... foaf:homepage ; ... foaf:name "Some Body" . ... ... a foaf:Image; ... rdfs:label "some 1"@en; ... rdfs:comment "Just an image"@en; ... foaf:thumbnail . ... ... a foaf:Image . ... ... [] a cv:CV; ... cv:aboutPerson ; ... cv:hasWorkHistory [ cv:employedIn ; ... cv:startDate "2009-09-04"^^xsd:date ] . ... ''') ``` Create a Resource: ```python >>> person = Resource( ... graph, URIRef("http://example.org/person/some1#self")) ``` Retrieve some basic facts: ```python >>> person.identifier rdflib.term.URIRef('http://example.org/person/some1#self') >>> person.value(FOAF.name) rdflib.term.Literal('Some Body') >>> person.value(RDFS.comment) rdflib.term.Literal('Just a Python & RDF hacker.', lang='en') ``` Resources can be sliced (like graphs, but the subject is fixed): ```python >>> for name in person[FOAF.name]: ... print(name) Some Body >>> person[FOAF.name : Literal("Some Body")] True ``` Resources as unicode are represented by their identifiers as unicode: ```python >>> %(unicode)s(person) #doctest: +SKIP 'Resource(http://example.org/person/some1#self' ``` Resource references are also Resources, so you can easily get e.g. a qname for the type of a resource, like: ```python >>> person.value(RDF.type).qname() 'foaf:Person' ``` Or for the predicates of a resource: ```python >>> sorted( ... p.qname() for p in person.predicates() ... ) #doctest: +NORMALIZE_WHITESPACE +SKIP ['foaf:depiction', 'foaf:homepage', 'foaf:name', 'rdf:type', 'rdfs:comment'] ``` Follow relations and get more data from their Resources as well: ```python >>> for pic in person.objects(FOAF.depiction): ... print(pic.identifier) ... print(pic.value(RDF.type).qname()) ... print(pic.value(FOAF.thumbnail).identifier) http://example.org/images/person/some1.jpg foaf:Image http://example.org/images/person/some1-thumb.jpg ``` ```python >>> for cv in person.subjects(CV.aboutPerson): ... work = list(cv.objects(CV.hasWorkHistory))[0] ... print(work.value(CV.employedIn).identifier) ... print(work.value(CV.startDate)) http://example.org/#company 2009-09-04 ``` It's just as easy to work with the predicates of a resource: ```python >>> for s, p in person.subject_predicates(): ... print(s.value(RDF.type).qname()) ... print(p.qname()) ... for s, o in p.subject_objects(): ... print(s.value(RDF.type).qname()) ... print(o.value(RDF.type).qname()) cv:CV cv:aboutPerson cv:CV foaf:Person ``` This is useful for e.g. inspection: ```python >>> thumb_ref = URIRef("http://example.org/images/person/some1-thumb.jpg") >>> thumb = Resource(graph, thumb_ref) >>> for p, o in thumb.predicate_objects(): ... print(p.qname()) ... print(o.qname()) rdf:type foaf:Image ``` ## Schema Example With this artificial schema data: ```python >>> graph = Graph().parse(format='n3', data=''' ... @prefix rdf: . ... @prefix rdfs: . ... @prefix owl: . ... @prefix v: . ... ... v:Artifact a owl:Class . ... ... v:Document a owl:Class; ... rdfs:subClassOf v:Artifact . ... ... v:Paper a owl:Class; ... rdfs:subClassOf v:Document . ... ... v:Choice owl:oneOf (v:One v:Other) . ... ... v:Stuff a rdf:Seq; rdf:_1 v:One; rdf:_2 v:Other . ... ... ''') ``` From this class: ```python >>> artifact = Resource(graph, URIRef("http://example.org/def/v#Artifact")) ``` we can get at subclasses: ```python >>> subclasses = list(artifact.transitive_subjects(RDFS.subClassOf)) >>> [c.qname() for c in subclasses] ['v:Artifact', 'v:Document', 'v:Paper'] ``` and superclasses from the last subclass: ```python >>> [c.qname() for c in subclasses[-1].transitive_objects(RDFS.subClassOf)] ['v:Paper', 'v:Document', 'v:Artifact'] ``` Get items from the Choice: ```python >>> choice = Resource(graph, URIRef("http://example.org/def/v#Choice")) >>> [it.qname() for it in choice.value(OWL.oneOf).items()] ['v:One', 'v:Other'] ``` On add, other resources are auto-unboxed: ```python >>> paper = Resource(graph, URIRef("http://example.org/def/v#Paper")) >>> paper.add(RDFS.subClassOf, artifact) >>> artifact in paper.objects(RDFS.subClassOf) # checks Resource instance True >>> (paper._identifier, RDFS.subClassOf, artifact._identifier) in graph True ``` ## Technical Details Comparison is based on graph and identifier: ```python >>> g1 = Graph() >>> t1 = Resource(g1, URIRef("http://example.org/thing")) >>> t2 = Resource(g1, URIRef("http://example.org/thing")) >>> t3 = Resource(g1, URIRef("http://example.org/other")) >>> t4 = Resource(Graph(), URIRef("http://example.org/other")) >>> t1 is t2 False >>> t1 == t2 True >>> t1 != t2 False >>> t1 == t3 False >>> t1 != t3 True >>> t3 != t4 True >>> t3 < t1 and t1 > t3 True >>> t1 >= t1 and t1 >= t3 True >>> t1 <= t1 and t3 <= t1 True >>> t1 < t1 or t1 < t3 or t3 > t1 or t3 > t3 False ``` Hash is computed from graph and identifier: ```python >>> g1 = Graph() >>> t1 = Resource(g1, URIRef("http://example.org/thing")) >>> hash(t1) == hash(Resource(g1, URIRef("http://example.org/thing"))) True >>> hash(t1) == hash(Resource(Graph(), t1.identifier)) False >>> hash(t1) == hash(Resource(Graph(), URIRef("http://example.org/thing"))) False ``` The Resource class is suitable as a base class for mapper toolkits. For example, consider this utility for accessing RDF properties via qname-like attributes: ```python >>> class Item(Resource): ... ... def __getattr__(self, p): ... return list(self.objects(self._to_ref(*p.split('_', 1)))) ... ... def _to_ref(self, pfx, name): ... return URIRef(self._graph.store.namespace(pfx) + name) ``` It works as follows: ```python >>> graph = Graph().parse(format='n3', data=''' ... @prefix rdfs: . ... @prefix foaf: . ... ... @base . ... ... foaf:name "Some Body"; ... foaf:depiction . ... rdfs:comment "Just an image"@en . ... ''') >>> person = Item(graph, URIRef("http://example.org/person/some1#self")) >>> print(person.foaf_name[0]) Some Body ``` The mechanism for wrapping references as resources cooperates with subclasses. Therefore, accessing referenced resources automatically creates new `Item` objects: ```python >>> isinstance(person.foaf_depiction[0], Item) True >>> print(person.foaf_depiction[0].rdfs_comment[0]) Just an image ``` )RDF)Path)BNodeNodeURIRefResourcec6\rSrSrSrSr\S5r\S5rSr Sr Sr S r S r S rS rS rSrS)SjrSrS)SjrS)SjrS)SjrSrSrSr\R6SSS4SjrSrS)SjrS)SjrSrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'S&r(S'r)S(r*g)*rihz>A Resource is a wrapper for a graph and a resource identifier.cXlX lgN_graph _identifier)selfgraphsubjects I/home/james-whalen/.local/lib/python3.13/site-packages/rdflib/resource.py__init__Resource.__init__ks  "cUR$r )r rs rrResource.graphos {{rcUR$r rrs r identifierResource.identifierssrcx[[5[UR5- [UR5- $r )hashrr rrs r__hash__Resource.__hash__ws*H~T[[ 11D9I9I4JJJrc[U[5=(a9 URUR:H=(a URUR:H$r ) isinstancerr rrothers r__eq__Resource.__eq__zs? uh ' 6 u||+ 6  E$5$55 rc X:X+$r r#s r__ne__Resource.__ne__s   rc`[U[5(aURUR:$g)NF)r"rrr#s r__lt__Resource.__lt__s) eX & &##e&7&77 7rc*X:=(d X:H(+$r r(r#s r__gt__Resource.__gt__sL1DM22rc X:=(d X:H$r r(r#s r__le__Resource.__le__s|,t},rc X:+$r r(r#s r__ge__Resource.__ge__s rc,[UR5$r )strrrs r __unicode__Resource.__unicode__s4##$$rc[U[5(a URnURR URX45 gr )r"rrr addrpos rr< Resource.add3 a " " A ))101rNc[U[5(a URnURR URX45 gr )r"rrr remover=s rrCResource.removes5 a " " A D,,a34rc[U[5(a URnURR URX45 gr )r"rrr setr=s rrF Resource.setrArcjURURRXR55$r ) _resourcesr subjectsrr predicates rrJResource.subjectss&t{{33I?O?OPQQrc[U[5(a URnURURR URU55$r )r"rrrIr predicates)rr?s rrOResource.predicatess> a " " At{{55d6F6FJKKrclURURRURU55$r )rIr objectsrrKs rrRResource.objectss(t{{2243C3CYOPPrcjURURRUR55$r )_resource_pairsr subject_predicatesrrs rrVResource.subject_predicatess(##DKK$B$B4CSCS$TUUrcjURURRUR55$r )rUr subject_objectsrrs rrYResource.subject_objectss(##DKK$?$?@P@P$QRRrcjURURRUR55$r )rUr predicate_objectsrrs rr\Resource.predicate_objectss(##DKK$A$A$BRBR$STTrTc [U[5(a URnURURR URXX455$r )r"rr_castr value)rr>r?defaultanys rr`Resource.values@ a " " Azz$++++D,<,r?s r_resource_triplesResource._resource_tripless8GA!**Q-A 1 = =sAAc#D# UHnURU5v M g7fr rs)rnodesnodes rrIResource._resourcessD**T" "s c^[U[[45(aURU5$U$r )r"rr_new)rrs rr_Resource._casts& dUFO , ,99T? "KrcpURURRURSS455$r )r{r ryrrs r__iter__Resource.__iter__s2%% KK  $ = >  rcZ[U[5(aUR(a [S5eURUR p2[U[ 5(a URn[U[ 5(a URnUcUcUR5$UcURU5$UcURU5$URX#4UR;$[U[[45(aURU5$[SU<S[U5<S35e)NzSResources fix the subject for slicing, and can only be sliced by predicate/object. zTYou can only index a resource by a single rdflib term, a slice of rdflib terms, not z ())r"slicestep TypeErrorstartstoprrr\rOrRrr rrtype)ritemr>r?s r __getitem__Resource.__getitem__s dE " "yyi::tyyq!X&&MM!X&&MMyQY--//q))||A&.$++== tTl + +<<% %d% rc&URX5 gr )rF)rrr`s r __setitem__Resource.__setitem__s rc:[U5"URU5$r )rr )rrs rr Resource._newsDz$++w//rc SUR-$)Nz Resource(%s)rrs r__str__Resource.__str__ s 0 000rc@SUR<SUR<S3$)Nz Resource(,rr rs r__repr__Resource.__repr__s$(KK1A1ABBrr r )+__name__ __module__ __qualname____firstlineno____doc__rpropertyrrrr%r)r,r/r2r5r9r<rCrFrJrOrRrVrYr\rr`rerhrmrprUr{rIr_rrrrrr__static_attributes__r(rrrrhsH#  K ! 3- %2 5 2 RL QVSUii44S D  31>#  601CrN) rrdflib.namespacer rdflib.pathsr rdflib.termrrr__all__rr(rrrs/^@ !++ ,gCgCr