
    01io#                     d    S r SSKJr  SSKJr  SSKJr  SSKJrJ	r	J
r
Jr   " S S5      rS rS	 rg
)a  
A Describer is a stateful utility for creating RDF statements in a
semi-declarative manner. It has methods for creating literal values, rel and
rev resource relations (somewhat resembling RDFa).

The `Describer.rel` and `Describer.rev` methods return a context manager which sets the current
about to the referenced resource for the context scope (for use with the
`with` statement).

Full example in the `to_rdf` method below:

```python
>>> import datetime
>>> from rdflib.graph import Graph
>>> from rdflib.namespace import Namespace, RDFS, FOAF

>>> ORG_URI = "http://example.org/"

>>> CV = Namespace("http://purl.org/captsolo/resume-rdf/0.2/cv#")

>>> class Person:
...     def __init__(self):
...         self.first_name = "Some"
...         self.last_name = "Body"
...         self.username = "some1"
...         self.presentation = "Just a Python & RDF hacker."
...         self.image = "/images/persons/" + self.username + ".jpg"
...         self.site = "http://example.net/"
...         self.start_date = datetime.date(2009, 9, 4)
...     def get_full_name(self):
...         return " ".join([self.first_name, self.last_name])
...     def get_absolute_url(self):
...         return "/persons/" + self.username
...     def get_thumbnail_url(self):
...         return self.image.replace('.jpg', '-thumb.jpg')
...
...     def to_rdf(self):
...         graph = Graph()
...         graph.bind('foaf', FOAF)
...         graph.bind('cv', CV)
...         lang = 'en'
...         d = Describer(graph, base=ORG_URI)
...         d.about(self.get_absolute_url()+'#person')
...         d.rdftype(FOAF.Person)
...         d.value(FOAF.name, self.get_full_name())
...         d.value(FOAF.givenName, self.first_name)
...         d.value(FOAF.familyName, self.last_name)
...         d.rel(FOAF.homepage, self.site)
...         d.value(RDFS.comment, self.presentation, lang=lang)
...         with d.rel(FOAF.depiction, self.image):
...             d.rdftype(FOAF.Image)
...             d.rel(FOAF.thumbnail, self.get_thumbnail_url())
...         with d.rev(CV.aboutPerson):
...             d.rdftype(CV.CV)
...             with d.rel(CV.hasWorkHistory):
...                 d.value(CV.startDate, self.start_date)
...                 d.rel(CV.employedIn, ORG_URI+"#company")
...         return graph
...
>>> person_graph = Person().to_rdf()
>>> expected = Graph().parse(data='''<?xml version="1.0" encoding="utf-8"?>
... <rdf:RDF
...   xmlns:foaf="http://xmlns.com/foaf/0.1/"
...   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
...   xmlns:cv="http://purl.org/captsolo/resume-rdf/0.2/cv#"
...   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
...   <foaf:Person rdf:about="http://example.org/persons/some1#person">
...     <foaf:name>Some Body</foaf:name>
...     <foaf:givenName>Some</foaf:givenName>
...     <foaf:familyName>Body</foaf:familyName>
...     <foaf:depiction>
...       <foaf:Image
...         rdf:about=
...             "http://example.org/images/persons/some1.jpg">
...         <foaf:thumbnail
...         rdf:resource=
...             "http://example.org/images/persons/some1-thumb.jpg"/>
...       </foaf:Image>
...     </foaf:depiction>
...     <rdfs:comment xml:lang="en">
...             Just a Python &amp; RDF hacker.
...     </rdfs:comment>
...     <foaf:homepage rdf:resource="http://example.net/"/>
...   </foaf:Person>
...   <cv:CV>
...     <cv:aboutPerson
...         rdf:resource="http://example.org/persons/some1#person">
...     </cv:aboutPerson>
...     <cv:hasWorkHistory>
...       <rdf:Description>
...         <cv:startDate
...             rdf:datatype="http://www.w3.org/2001/XMLSchema#date"
...             >2009-09-04</cv:startDate>
...         <cv:employedIn rdf:resource="http://example.org/#company"/>
...       </rdf:Description>
...     </cv:hasWorkHistory>
...   </cv:CV>
... </rdf:RDF>
... ''', format="xml")

>>> from rdflib.compare import isomorphic
>>> isomorphic(person_graph, expected)  #doctest: +SKIP
True

```
    )contextmanager)Graph)RDF)BNode
IdentifierLiteralURIRefc                   Z    \ rS rSrSS jrS rS rSS jrSS jrS r	S	 r
\S
 5       rSrg)	Describers   Nc                 x    Uc
  [        5       nXl        X0l        / U l        U R	                  U=(       d    S 5        g N)r   graphbase	_subjectsabout)selfr   r   r   s       Q/home/james-whalen/.local/lib/python3.13/site-packages/rdflib/extras/describer.py__init__Describer.__init__t   s/    =GE
	

5=D!    c                     UR                  SU R                  5        [        U40 UD6nU R                  (       a  XR                  S'   gU R                  R	                  U5        g)aN  
Sets the current subject. Will convert the given object into an
`URIRef` if it's not an `Identifier`.

Example:
    ```python
    >>> d = Describer()
    >>> d._current() #doctest: +ELLIPSIS
    rdflib.term.BNode(...)
    >>> d.about("http://example.org/")
    >>> d._current()
    rdflib.term.URIRef('http://example.org/')

    ```
r   N)
setdefaultr   cast_identifierr   append)r   subjectkwss      r   r   Describer.about|   sJ      	vtyy)!'1S1>>!(NN2NN!!'*r   c                 r    [        U40 UD6nU R                  R                  U R                  5       X45        g)a  
Set a literal value for the given property. Will cast the value to an
`Literal` if a plain literal is given.

Example:
    ```python
    >>> from rdflib import URIRef
    >>> from rdflib.namespace import RDF, RDFS
    >>> d = Describer(about="http://example.org/")
    >>> d.value(RDFS.label, "Example")
    >>> d.graph.value(URIRef('http://example.org/'), RDFS.label)
    rdflib.term.Literal('Example')

    ```
N)
cast_valuer   add_current)r   pvr   s       r   valueDescriber.value   s.      q C 

./r   c                     UR                  SU R                  5        [        U5      n[        U40 UD6nU R                  R	                  U R                  5       X45        U R                  U5      $ )a  Set an object for the given property. Will convert the given object
into an `URIRef` if it's not an `Identifier`. If none is given, a
new `BNode` is used.

Returns a context manager for use in a `with` block, within which the
given object is used as current subject.

Example:
    ```python
    >>> from rdflib import URIRef
    >>> from rdflib.namespace import RDF, RDFS
    >>> d = Describer(about="/", base="http://example.org/")
    >>> _ctxt = d.rel(RDFS.seeAlso, "/about")
    >>> d.graph.value(URIRef('http://example.org/'), RDFS.seeAlso)
    rdflib.term.URIRef('http://example.org/about')

    >>> with d.rel(RDFS.seeAlso, "/more"):
    ...     d.value(RDFS.label, "More")
    >>> (URIRef('http://example.org/'), RDFS.seeAlso,
    ...         URIRef('http://example.org/more')) in d.graph
    True
    >>> d.graph.value(URIRef('http://example.org/more'), RDFS.label)
    rdflib.term.Literal('More')

    ```
r   r   r   r   r   r"   r#   _subject_stack)r   r$   or   s       r   relDescriber.rel   s[    8 	vtyy)AA%%

./""1%%r   c                     UR                  SU R                  5        [        U5      n[        U40 UD6nU R                  R	                  X!U R                  5       45        U R                  U5      $ )aq  
Same as `rel`, but uses current subject as *object* of the relation.
The given resource is still used as subject in the returned context
manager.

Example:
    ```python
    >>> from rdflib import URIRef
    >>> from rdflib.namespace import RDF, RDFS
    >>> d = Describer(about="http://example.org/")
    >>> with d.rev(RDFS.seeAlso, "http://example.net/"):
    ...     d.value(RDFS.label, "Net")
    >>> (URIRef('http://example.net/'), RDFS.seeAlso,
    ...         URIRef('http://example.org/')) in d.graph
    True
    >>> d.graph.value(URIRef('http://example.net/'), RDFS.label)
    rdflib.term.Literal('Net')

    ```
r   r)   )r   r$   sr   s       r   revDescriber.rev   s[    * 	vtyy)AA%%

dmmo./""1%%r   c                 x    U R                   R                  U R                  5       [        R                  U45        g)a^  Shorthand for setting rdf:type of the current subject.

Example:
    ```python
    >>> from rdflib import URIRef
    >>> from rdflib.namespace import RDF, RDFS
    >>> d = Describer(about="http://example.org/")
    >>> d.rdftype(RDFS.Resource)
    >>> (URIRef('http://example.org/'),
    ...     RDF.type, RDFS.Resource) in d.graph
    True

    ```
N)r   r"   r#   r   type)r   ts     r   rdftypeDescriber.rdftype   s%     	

156r   c                      U R                   S   $ )Nr   )r   )r   s    r   r#   Describer._current   s    ~~b!!r   c              #   ~   #    U R                   R                  U5        S v   U R                   R                  5         g 7fr   )r   r   pop)r   r   s     r   r*   Describer._subject_stack   s,     g&
s   ;=)r   r   r   )NNNr   )__name__
__module____qualname____firstlineno__r   r   r&   r,   r0   r5   r#   r   r*   __static_attributes__ r   r   r   r   s   s:    "+.0& &D&67""  r   r   c                 H    [        U [        5      (       d  [        U 40 UD6n U $ r   )
isinstancer   )r%   r   s     r   r!   r!      s#    a!!AHr   c                 n    U =(       d
    [        5       n [        U [        5      (       d  [        U 40 UD6n U $ r   )r   rC   r   r	   )refr   s     r   r   r     s.    
.Cc:&&S C Jr   N)__doc__
contextlibr   rdflib.graphr   rdflib.namespacer   rdflib.termr   r   r   r	   r   r!   r   rA   r   r   <module>rK      s4   iV &    : :H HVr   