Changeset 91

Show
Ignore:
Timestamp:
02/04/08 10:31:17 (4 years ago)
Author:
phil
Message:

BIG CHANGES!
rdfObject is now rdfSubject
rdfSubject is not an rdflib.Identifier so it works in db.triples() type calls
set works now for rdflibMulti
set works for List and Collection type descriptors
descriptors are split into a separate file
added first nose test file

Location:
rdfalchemy/trunk
Files:
3 added
8 modified

Legend:

Unmodified
Added
Removed

  • rdfalchemy/trunk/rdfalchemy/engine/__init__.py

    r64 r91  
    1414    for zodb: 
    1515       the key in the Zope database is hardcoded as 'rdflib' 
    16        urls inding with .fs indicate FileStorage 
     16       urls ending in `.fs` indicate FileStorage 
    1717       otherwise ClientStoreage is assumed which requires 
    1818       a ZEO Server to be running""" 

  • rdfalchemy/trunk/rdfalchemy/__init__.py

    r59 r91  
    11from rdfalchemy import * 
     2from descriptors import * 

  • rdfalchemy/trunk/rdfalchemy/rdfalchemy.py

    r89 r91  
    3333from rdflib import ConjunctiveGraph 
    3434from rdflib import Literal, BNode, Namespace, URIRef 
    35 from itertools import chain 
     35from rdflib.Identifier import Identifier  
     36from rdflib.exceptions import * 
    3637import re 
     38 
     39try: 
     40    from hashlib import md5 
     41except ImportError: 
     42    from md5 import md5     
     43 
    3744import logging 
    38  
    3945##console = logging.StreamHandler() 
    40 ## console.setLevel(logging.DEBUG)    ## <- the debug level goes here 
    4146##formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') 
    4247##console.setFormatter(formatter) 
    … …  
    5156re_ns_n = re.compile('(.*[/#])(.*)') 
    5257 
    53 from exceptions import * 
    5458     
    5559# Look into caching as in: 
    … …  
    5862#       Data descriptors (get and set) use the __get__ first 
    5963 
    60 # helper function, might be somewhere in rdflib I need to look for it there 
    61 def getList(sub, pred=None, db=None): 
    62     """Attempts to return a list from sub (subject that is) 
    63     passed in if it is a Collection or a Container (Bag,Seq or Alt)""" 
    64     if not db: 
    65         if isinstance(sub,rdfObject): 
    66             db=sub.db 
    67         else: 
    68             db=rdfObject.db 
    69     if pred: 
    70         if isinstance(sub, rdfObject): 
    71             subUri=sub.resUri         
    72         base = db.value(subUri,pred,any=True) 
    73     else: 
    74         # if there was no predicate assume a base node was passed in 
    75         base=sub 
    76     if type(base) != BNode: 
    77         # Doesn't look like a list or a collection, just return multiple values (or an error?) 
    78         val=[o for o in db.objects(subUri, pred)] 
    79         return val 
    80     members=[] 
    81     first = db.value(base, RDF.first) 
    82     # OK let's work at returning a list if there is an RDF.first 
    83     if first: 
    84         while first: 
    85             members.append(first) 
    86             base = db.value(base, RDF.rest) 
    87             first = db.value(base, RDF.first) 
    88         return members 
    89     # OK let's work at returning a Collection (Seq,Bag or Alt) if was no RDF.first 
    90     else: 
    91         i=1         
    92         first=db.value(base, RDF._1) 
    93         if not first: 
    94             raise AttributeError, "Not a list, or collection but another type of BNode" 
    95         while first: 
    96             members.append(first) 
    97             i += 1 
    98             first=db.value(base, RDF['_%d'%i]) 
    99         return members 
    100  
    101 class rdflibAbstract(object): 
    102     """Abstract base class for descriptors 
    103     Descriptors are to map class instance variables to predicates 
    104     optional cacheName is where to store items 
    105     range_type is the rdf:type of the range of this predicate""" 
    106     def __init__(self, pred, cacheName=None, range_type=None): 
    107         self.pred = pred 
    108         self.name = cacheName or pred 
    109         self.range_type = range_type 
    110      
    111     @property 
    112     def range_class(self): 
    113         """return the class that this descriptor is mapped to through the range_type""" 
    114         if self.range_type: 
    115             try: 
    116                 return self._mappedClass 
    117             except AttributeError: 
    118                 log.warn("Descriptor %s has range of: %s but not yet mapped"%(self, self.range_type)) 
    119                 return rdfObject 
    120         else: 
    121             return rdfObject 
    122              
    123     def __delete__(self, obj): 
    124         """deletes or removes from the database triples with: 
    125           obj.resUri as subject and self.pred as predicate 
    126           if the object of that triple is a Literal that stop 
    127           if the object of that triple is a BNode  
    128           then cascade the delete if that BNode has no further references to it 
    129           i.e. it is not the object in any other triples. 
    130         """  
    131         # be done ala getList above 
    132         log.debug("DELETE with descriptor for %s on %s"%(self.pred, obj.resUri))         
    133         # first drop the cached value 
    134         del obj.__dict__[self.name] 
    135         # next, drop the triples          
    136         for s,p,o in obj.db.triples((obj.resUri, self.pred, None)): 
    137             obj.db.remove((s,p,o)) 
    138             #finally if the object in the triple was a bnode  
    139             #cascade delete the thing it referenced 
    140             if isinstance(o,BNode): 
    141                 rdfObject(o).remove(db=obj.db,cascade='bnode') 
    142  
    143  
    144  
    145                      
    146 class rdflibSingle(rdflibAbstract): 
    147     '''This is a Discriptor 
    148     Takes a the URI of the predicate at initialization 
    149     Expects to return a single item 
    150     on Assignment will set that value to the  
    151     ONLY triple with that subject,predicate pair''' 
    152     def __init__(self, pred, cacheName=None, range_type=None): 
    153         super(rdflibSingle, self).__init__(pred, cacheName, range_type) 
    154          
    155     def __get__(self, obj, cls): 
    156         if obj is None: 
    157             return self 
    158         if self.name in obj.__dict__: 
    159             return obj.__dict__[self.name] 
    160         log.debug("Geting with descriptor %s for %s"%(self.pred,obj.resUri)) 
    161         val=obj.__getitem__(self.pred)         
    162         if isinstance(val, rdfObject) or isinstance(val, BNode) or isinstance(val,URIRef): 
    163             val = self.range_class(val) 
    164         obj.__dict__[self.name]= val 
    165         return val 
    166      
    167     def __set__(self, obj, value): 
    168         log.debug("SET with descriptor value %s of type %s"%(value,type(value))) 
    169         #setattr(obj, self.name, value)  #this recurses indefinatly 
    170         obj.__dict__[self.name]= value 
    171         if isinstance(value,Literal) or isinstance(value,URIRef) or isinstance(value,BNode): 
    172             o = value 
    173         elif isinstance(value,rdfObject): 
    174             o = value.resUri 
    175         else: 
    176             o = Literal(value) 
    177         obj.db.set((obj.resUri,self.pred, o)) 
    178         #return None 
    179      
    180     
    181 class rdflibMultiple(rdflibAbstract): 
    182     '''This is a Discriptor     
    183        Expects to return a list of values (could be a list of one)''' 
    184     def __init__(self, pred, cacheName=None, range_type=None): 
    185         super(rdflibMultiple, self).__init__(pred, cacheName, range_type) 
    186          
    187     def __get__(self, obj, cls): 
    188         if obj is None: 
    189             return self 
    190         val=[o for o in obj.db.objects(obj.resUri, self.pred)] 
    191         # check to see if this is a Container or Collection 
    192         # if so, return collection as a list 
    193         if len(val) == 1 \ 
    194            and (obj.db.value(o,RDF.first) or obj.db.value(o,RDF._1)):  
    195                   val=getList(obj, self.pred) 
    196         val=[((isinstance(v,BNode) or isinstance(v,URIRef)) and self.range_class(v) or v) for v in val] 
    197         setattr(obj, self.name, val) 
    198         try: 
    199             log.debug("Geting %s for %s"%(obj.db.qname(self.pred),obj.db.qname(obj.resUri))) 
    200         except: 
    201             log.debug("Geting %s for %s"%(self.pred,obj.resUri)) 
    202         return val 
    203          
    204  
    205  
    206  
    207 class rdflibList(rdflibMultiple): 
    208     '''This is a Discriptor     
    209        Expects to return a list of values (could be a list of one)''' 
    210     def __init__(self, pred, cacheName=None, range_type=None): 
    211         super(rdflibMultiple, self).__init__(pred, cacheName, range_type) 
    212          
    213     def __get__(self, obj, cls): 
    214         if obj is None: 
    215             return self         
    216         #log.debug("Geting %s for %s"%(obj.db.qname(self.pred),obj.db.qname(obj.resUri))) 
    217         log.debug("Geting %s for %s"%(self.pred,obj.resUri)) 
    218         base = obj.db.value(obj.resUri,self.pred) 
    219         if not base: 
    220             return [] 
    221         members=[] 
    222         first = obj.db.value(base, RDF.first) 
    223         # OK let's work at returning a list if there is an RDF.first 
    224         if not first: 
    225             raise AttributeError, ("expected node [%s] to be a list but it's not" %base.n3()) 
    226         while first: 
    227             members.append(first) 
    228             base = db.value(base, RDF.rest) 
    229             first = db.value(base, RDF.first) 
    230  
    231         val=[((isinstance(v,BNode) or isinstance(v,URIRef)) and self.range_class(v) or v) for v in members] 
    232         setattr(obj, self.name, members) 
    233         return members 
    234          
    235 class rdflibContainer(rdflibMultiple): 
    236     '''This is a Discriptor     
    237        Expects to return a list of values (could be a list of one)''' 
    238     def __init__(self, pred, cacheName=None, range_type=None): 
    239         super(rdflibMultiple, self).__init__(pred, cacheName, range_type) 
    240          
    241     def __get__(self, obj, cls): 
    242         if obj is None: 
    243             return self         
    244         #log.debug("Geting %s for %s"%(obj.db.qname(self.pred),obj.db.qname(obj.resUri))) 
    245         log.debug("Geting %s for %s"%(self.pred,obj.resUri)) 
    246         base = obj.db.value(obj.resUri,self.pred) 
    247         if not base: 
    248             return [] 
    249         members=[] 
    250         i=1         
    251         first=db.value(base, RDF._1) 
    252         if not first: 
    253             raise AttributeError, ("expected node [%s] to be a list but it's not" % base.n3()) 
    254         while first: 
    255             members.append(first) 
    256             i += 1 
    257             first=db.value(base, RDF['_%d'%i]) 
    258  
    259         val=[((isinstance(v,BNode) or isinstance(v,URIRef)) and self.range_class(v) or v) for v in members] 
    260         setattr(obj, self.name, members) 
    261         return members 
    262          
    263  
    264  
    265 class rdfObject(object): 
     64 
     65################################################################################## 
     66# define our Base Class for all "subjects" in python  
     67################################################################################## 
     68 
     69#class rdfSubject(object): 
     70class rdfSubject(Identifier): 
    26671    db=ConjunctiveGraph() 
    26772    """Default graph for access to instances of this type""" 
    26873    rdf_type=None 
    26974    """rdf:type of instances of this class""" 
    270     def __init__(self, resUri): 
    271         """The constructor tries hard to do return you an rdfObject 
     75    def __new__(cls, resUri = None, **kwargs): 
     76        """docstring for __new__""" 
     77        if not resUri or isinstance(resUri, BNode): 
     78            sub = BNode.__new__(cls, resUri) 
     79            sub.node_type = 'bnode' 
     80        elif isinstance(resUri, (str, unicode)) and resUri.startswith("_:"): 
     81            sub = BNode.__new__(cls, resUri[2:]) 
     82            sub.node_type = 'bnode' 
     83        elif isinstance(resUri, URIRef): 
     84            sub = URIRef.__new__(cls, resUri) 
     85            sub.node_type = 'uri' 
     86        elif isinstance(resUri, (str, unicode)) and resUri[0]=="<" and resUri[-1]==">": 
     87            sub = URIRef.__new__(cls, resUri[1:-1]) 
     88            sub.node_type = 'uri' 
     89        elif isinstance(resUri, rdfSubject): 
     90            sub = Identifier.__new__(cls, resUri)  
     91            sub.node_type = resUri.node_type 
     92            if sub.db != resUri.db: 
     93               sub.db = resUri.db 
     94        else: 
     95            raise AttributeError("cannot construct rdfSubject from %s"%(str(resUri))) 
     96        return sub 
     97 
     98    def __init__(self, resUri = None, **kwargs): 
     99        """The constructor tries hard to do return you an rdfSubject 
    272100        the parameter resUri can be: 
    273          * an instance of an rdfObject 
     101         * an instance of an rdfSubject 
    274102         * an instance of a BNode or a URIRef 
    275103         * an n3 uriref string like: <urn:isbn:1234567890> 
    276          * an n3 bnode string like _:xyz1234 """ 
    277         if isinstance(resUri, rdfObject): 
    278             self.resUri=resUri.resUri  
    279             self.db=resUri.db 
    280         elif isinstance(resUri, BNode) or isinstance(resUri, URIRef): 
    281             self.resUri=resUri 
    282         elif resUri[0]=="<" and resUri[-1]==">": 
    283             self.resUri=URIRef(resUri[1:-1]) 
    284         elif resUri.startswith("_:"): 
    285             self.resUri=BNode(resUri[2:]) 
    286         else: 
    287             raise AttributeError("cannot construct rdfObject from %s"%(str(resUri))) 
    288              
    289         rdftype = list(self.db.objects(self.resUri, RDF.type)) 
     104         * an n3 bnode string like _:xyz1234  
     105        a null resUri will cause a new one created of  
     106        this classes rdf_type 
     107         `kwargs` is a set of values that will be set""" 
     108        if kwargs: 
     109            self._set_with_dict(kwargs) 
     110 
     111        if not resUri: 
     112            # lets create a new one 
     113            if self.rdf_type: 
     114                self.db.set((self,RDF.type, self.rdf_type)) 
     115        # lets get a default namespace for this  
     116        # ??obsolete ??? 
     117        rdftype = list(self.db.objects(self, RDF.type)) 
    290118        if len(rdftype)==1: 
    291119            self.namespace, trash = re_ns_n.match(rdftype[0]).groups() 
    292120            self.namespace=Namespace(self.namespace) 
    293         elif isinstance(self.resUri,URIRef): 
    294             ns_n =  re_ns_n.match(self.resUri) 
     121        elif isinstance(self,URIRef): 
     122            ns_n =  re_ns_n.match(self) 
    295123            if ns_n: 
    296124                self.namespace, self.name = ns_n.groups() 
    … …  
    298126                 
    299127    def n3(self): 
    300         return self.resUri.n3() 
    301                  
     128        """n3 repr of this node""" 
     129        if self.node_type == 'bnode': 
     130            return "_:%s"%self 
     131        elif self.node_type == 'uri': 
     132            return "<%s>"%self 
     133        else: 
     134            raise AttributeError("Unknown node type for %s"(self)) 
     135         
    302136 
    303137    @classmethod 
    … …  
    312146        raise AttributeError("descriptor %s not found for class %s" % (key,cls)) 
    313147         
     148    #short term hack.  Need to go to a sqlalchemy 0.4 style query method 
     149    # obj.query.get_by should map to obj.get_by  ..same for fetch_by 
     150    @property 
     151    def query(self): 
     152        return self     
    314153 
    315154    @classmethod 
    … …  
    325164            that is of type owl:InverseFunctional""" 
    326165        if len(kwargs) != 1: 
    327             raise ValueError("get_by did not want %i args"%(len(kwargs))) 
     166            raise ValueError("get_by wanted eaactly 1 but got  %i args\nMaybe you wanted filter_by"%(len(kwargs))) 
    328167        key,value = kwargs.items()[0] 
    329168        if isinstance(value, URIRef) or isinstance(value,BNode) or isinstance(value,Literal): 
    … …  
    337176        else: 
    338177            raise LookupError("%s = %s not found"%(key,value)) 
    339     #short term hack.  Need to go to a sqlalchemy 0.4 style query method 
    340     query_get_by=get_by 
    341          
    342178 
    343179    @classmethod 
    … …  
    356192            pred = cls._getdescriptor(key).pred 
    357193            # try to make the value be OK for the triple query as an object 
    358             if isinstance(value, rdfObject): 
    359                 obj = rdfObject.resUri 
    360             elif isinstance(value, URIRef) or isinstance(value,BNode): 
     194            if isinstance(value, Identifier): 
    361195                obj = value 
    362196            else: 
    … …  
    367201            filters.append((RDF.type,cls.rdf_type)) 
    368202        pred, obj = filters[0] 
    369         print "Checking %s, %s" % (pred,obj) 
     203        log.debug("Checking %s, %s" % (pred,obj)) 
    370204        for sub in cls.db.subjects(pred,obj): 
    371             print "maybe %s" % sub 
     205            log.debug( "maybe %s" % sub ) 
    372206            for pred,obj in filters[1:]: 
    373                 print "Checking %s, %s" % (pred,obj) 
    374                 if not list(cls.db.triples((sub,pred,obj))): 
    375                     print "Not %s" % s 
    376                     continue 
    377             yield cls(sub) 
     207                log.debug("Checking %s, %s" % (pred,obj)) 
     208                try: 
     209                    cls.db.triples((sub,pred,obj)).next() 
     210                except: 
     211                    log.warn( "No %s" % sub ) 
     212                    break 
     213            else: 
     214                yield cls(sub) 
    378215         
    379216    @classmethod 
    … …  
    392229         
    393230    def __repr__(self): 
    394         return "<%s: %s>"%(self.__class__.__name__, self.n3()) 
    395  
     231        return """%s('%s')""" % (self.__class__.__name__, self.n3()) 
     232     
    396233    def __getitem__(self, pred): 
    397         #log.debug("Geting with __getitem__ %s for %s"%(self.db.qname(pred),self.db.qname(self.resUri))) 
    398         log.debug("Geting with __getitem__ %s for %s"%(pred,self.resUri)) 
    399         val=self.db.value(self.resUri,pred) 
     234        #log.debug("Getting with __getitem__ %s for %s"%(self.db.qname(pred),self.db.qname(self.resUri))) 
     235        log.debug("Getting with __getitem__ %s for %s"%(pred,self.n3())) 
     236        val=self.db.value(self,pred) 
    400237        if isinstance(val,Literal): 
    401238            val =  val.toPython()  
    402239        elif isinstance(val, BNode) or isinstance(val,URIRef):  
    403             val=rdfObject(val)  
     240            val=rdfSubject(val)  
    404241        return val 
    405242         
    406     def remove(self, node=None, db=None, cascade = 'bnode', bnodeCheck=True): 
    407         """remove all triples where this rdfObject is the subject of the triple 
     243    ## def __setitem__(self,pred,value): 
     244    ## not even sure if this is a good idea here 
     245         
     246    def __delitem__(self, pred): 
     247        #log.debug("Deleting with __delitem__ %s for %s"%(self.db.qname(pred),self.db.qname(self.resUri))) 
     248        log.debug("Deleting with __delitem__ %s for %s"%(pred,self)) 
     249        for s,p,o in self.db.triples((self, pred, None)): 
     250            self.db.remove((s,p,o)) 
     251            #finally if the object in the triple was a bnode  
     252            #cascade delete the thing it referenced 
     253            if isinstance(o,BNode): 
     254                rdfSubject(o)._remove(db=self.db,cascade='bnode') 
     255         
     256    def _set_with_dict(self, kv): 
     257        """for each key,value pair in dict kv 
     258               set self.key = value""" 
     259        for key,value in kv.items(): 
     260            #item.__class__._getdescriptor('authors').__get__(item, item.__class__) 
     261            descriptor = self.__class__._getdescriptor(key) 
     262            descriptor.__set__(self, value) 
     263         
     264         
     265    def _remove(self, node=None, db=None, cascade = 'bnode', bnodeCheck=True): 
     266        """remove all triples where this rdfSubject is the subject of the triple 
    408267        db -- limit the remove operation to this graph 
    409268        node -- node to remove from the graph defaults to self 
    … …  
    420279        """ 
    421280        if not node: 
    422             node = self.resUri 
     281            node = self 
    423282        log.debug("Called remove on %s" % node) 
    424283        if not db: 
    … …  
    426285        # we cannot delete a bnode if it is still referenced,  
    427286        # i.e. if it is the o of a s,p,o  
    428         if bnodeCheck and isinstance(node,BNode): 
    429             for s,p,o in db.triples((None,None,node)): 
    430                 raise RDFAlchemyError("Cannot delete a bnode %s becuase %s still references it" % (node.n3(), s.n3())) 
     287        if bnodeCheck: 
     288            if isinstance(node,BNode) or isinstance(node,rdfSubject) and node.node_type=='bnode': 
     289                for s,p,o in db.triples((None,None,node)): 
     290                    raise RDFAlchemyError("Cannot delete a bnode %s becuase %s still references it" % (node.n3(), s.n3())) 
    431291        # determine an appropriate test for cascade decisions 
    432292        if cascade == 'bnode': 
    433293            #we cannot delete a bnode if there are still references to it 
    434294            def test(node): 
    435                 if not isinstance(node,BNode): 
     295                if isinstance(node,(URIRef,Literal)) \ 
     296                   or isinstance(node,rdfSubject) and node.node_type <> 'bnode': 
    436297                    return False 
    437298                for s,p,o in db.triples((None,None,node)): 
    … …  
    453314            db.remove((s,p,o)) 
    454315            if test(o): 
    455                 self.remove(node=o, db=db,cascade=cascade) 
     316                self._remove(node=o, db=db,cascade=cascade) 
    456317                 
    457     def rename(self, name, db=None): 
     318    def _rename(self, name, db=None): 
    458319        """rename a node """ 
    459320        if not db: 
    … …  
    461322        if not (isinstance(name,BNode) or isinstance(name,URIRef)): 
    462323            raise AttributeError, ("cannot rename to %s" % name) 
    463         for s,p,o in db.triples((self.resUri,None,None)): 
     324        for s,p,o in db.triples((self,None,None)): 
    464325            db.set((name, p, o)) 
    465         for s,p,o in db.triples((None,None,self.resUri)): 
     326        for s,p,o in db.triples((None,None,self)): 
    466327            db.set((s, p, name)) 
    467328        self.resUri = name 
    468329         
    469330         
    470     def ppo(self,db=None): 
     331    def _ppo(self,db=None): 
    471332        """Like pretty print... 
    472333        Return a 'pretty predicate,object' of self 
    473334        returning all predicate object pairs with qnames""" 
    474335        db = db or self.db 
    475         for p,o in db.predicate_objects(self.resUri): 
     336        for p,o in db.predicate_objects(self): 
    476337            print "%20s = %s"% (db.qname(p),str(o)) 
     338        print " " 
     339 
     340    def md5_term_hash(self): 
     341        d = md5(str(self)) 
     342        d.update("R") 
     343        return d.hexdigest() 
     344         
     345     
     346 

  • rdfalchemy/trunk/rdfalchemy/samples/company.py

    r76 r91  
    22from rdflib import Literal, BNode, Namespace, URIRef 
    33 
    4 # this has the rdfObject stuff and the Fresnel stuff 
     4# this has the rdfSubject stuff and the Fresnel stuff 
    55from rdfalchemy import * 
    66 
    … …  
    99edgarns = Namespace('http://www.sec.gov/Archives/edgar') 
    1010 
    11 class Company(rdfObject): 
     11class Company(rdfSubject): 
    1212    rdf_type = ov.Company 
    1313    symbol = rdflibSingle(ov.symbol,) 
    … …  
    1919                                                                                                                                         
    2020 
    21 class EdgarFiling(rdfObject): 
     21class EdgarFiling(rdfSubject): 
    2222    rdf_type = edgarns.xbrlFiling 
    2323    accessionNumber = rdflibSingle(edgarns.accessionNumber) 

  • rdfalchemy/trunk/rdfalchemy/samples/data/rdfalchemy_doap.n3

    r65 r91  
    55[ a :Project; 
    66         :name "RDFAlchemy"; 
    7          :description """RDFAlchemy is to RDF as SQLAlchemy is to SQL. 
    8 It is an ORM that allows access to rdflib or sesame RDF datastores"""; 
     7         :programming-language "Python"; 
    98         :homepage <http://www.openvest.com/trac/wiki/RDFAlchemy>; 
    109         :license <http://usefulinc.com/doap/licenses/bsd>; 
    … …  
    1312                 foaf:homepage <http://www.openvest.com/ContactUs>; 
    1413                 foaf:mbox_sha1sum "cc886cc71aeae9895a9e1e1e2a99a143a01d2d13"]; 
    15  
    16          :programming-language "Python"; 
    1714         :repository [ a :SVNRepository; 
    1815                 :browse <http://www.openvest.com/trac/browser/rdfalchemy/trunk>; 
    19                  :location <http://www.openvest.com/svn/public/rdfalchemy/trunk>; 
    20                  :shortdesc "A python orm for rdf datastores"].                           
     16                 :location <http://www.openvest.com/svn/public/rdfalchemy/trunk>]; 
     17                 :shortdesc "A python orm for rdf datastores"; 
     18                 :description """RDFAlchemy is to RDF as SQLAlchemy is to SQL. 
     19It is an ORM that allows access to rdflib or sesame RDF datastores"""; 
     20].                                

  • rdfalchemy/trunk/rdfalchemy/samples/doap.py

    r86 r91  
    1 from rdfalchemy import rdfObject, rdflibSingle, rdflibMultiple 
     1from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
    22from rdflib import Namespace 
    33 
    … …  
    66 
    77 
    8 class Project(rdfObject): 
     8class Project(rdfSubject): 
    99    rdf_type = DOAP.Project 
    1010    name = rdflibSingle(DOAP.name) 
    … …  
    1313    shortdesc = rdflibMultiple(DOAP.shortdesc) 
    1414    releases = rdflibMultiple(DOAP.release) 
     15    language = rdflibSingle(DOAP['programming-language']) # the hyphen means we can't use DOAP.programming-language 
    1516    maintainer = rdflibSingle(DOAP.maintainer,range_type=FOAF.Person) 
    1617 
    1718if __name__ == '__main__': 
    1819    from rdflib import ConjunctiveGraph 
    19     rdfObject.db=ConjunctiveGraph() 
     20    rdfSubject.db=ConjunctiveGraph() 
    2021    accs_uri="http://doapspace.org/doap/sf/accs.rdf" 
    21     rdfObject.db.load(accs_uri) 
     22    rdfSubject.db.load(accs_uri) 
    2223 
    2324    p = Project.ClassInstances().next() 

  • rdfalchemy/trunk/rdfalchemy/samples/example.py

    r72 r91  
    1 from rdfAlchemy import rdfObject, rdflibSingle, rdflibMultiple 
     1from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
    22from rdflib import ConjunctiveGraph, Namespace, Literal 
    33 
    … …  
    55VCARD = Namespace("http://www.w3.org/2006/vcard/ns#") 
    66 
    7 rdfObject.db = ConjunctiveGraph() 
    8 rdfObject.db.load('./example.n3', format='n3') 
     7rdfSubject.db = ConjunctiveGraph() 
     8rdfSubject.db.load('./data/example.n3', format='n3') 
    99 
    10 class Company(rdfObject): 
     10class Company(rdfSubject): 
    1111    owlType = OV.Company 
    1212    symbol = rdflibSingle(OV.symbol,'symbol') 
    … …  
    4949 
    5050## add an attribute (from the database) 
    51 c = Company.get_by(symbol = 'Java') 
     51c = Company.get_by(symbol = 'JAVA') 
    5252c.industry = 'Computer stuff' 
    5353 

  • rdfalchemy/trunk/rdfalchemy/samples/foaf.py

    r72 r91  
    77Copyright (c) 2007 Openvest. All rights reserved. 
    88""" 
    9 from rdfalchemy import rdfObject, rdflibSingle, rdflibMultiple 
     9from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
    1010from rdflib import Namespace 
    1111 
    1212FOAF=Namespace("http://xmlns.com/foaf/0.1/" ) 
    1313 
    14 class Agent(rdfObject): 
     14class Agent(rdfSubject): 
    1515    rdf_type = FOAF.Agent 
    1616    name = rdflibSingle(FOAF.name) 
    … …  
    2121    rdf_type = FOAF.Person 
    2222    first = rdflibSingle(FOAF.firstName,'first') 
    23     given = rdflibSingle(FOAF.givenname,'first') 
    2423    last = rdflibSingle(FOAF.surname,'last') 
    25     family = rdflibSingle(FOAF.family_name,'last') 
     24    givenname = rdflibSingle(FOAF.givenname,'first') 
     25    surname = rdflibSingle(FOAF.surname,'last') 
    2626