Changeset 136

Timestamp:

05/26/08 15:26:01 (4 years ago)

Author:

phil

Message:

RDFAlchemy added descriptors for locale and some tests

Location:

rdfalchemy/trunk

Files:

• rdfalchemy/descriptors.py (modified) (8 diffs)
• rdfalchemy/__init__.py (modified) (1 diff)
• rdfalchemy/rdfsSubject.py (modified) (5 diffs)
• rdfalchemy/rdfSubject.py (modified) (2 diffs)
• test/locale_test.py (added)
• test/subclass_test.py (modified) (2 diffs)
• test/subDocument_test.py (added)

rdfalchemy/trunk/rdfalchemy/descriptors.py

@@ -15 +15 @@
 import logging
 
-__all__=["rdfSingle","rdfMultiple","rdfList","rdfContainer"]
+__all__=["rdfSingle","rdfMultiple","rdfList","rdfContainer","owlTransitive"]
 
 #console = logging.StreamHandler()
@@ -82 +82 @@
 # each one will map an attribute of a class (derived from rdfObjet) to a predicate 
 ##################################################################################
+
 
 class rdfAbstract(object):
@@ -167 +168 @@
             return obj.__dict__[self.name]
         val=[o for o in obj.db.objects(obj.resUri, self.pred)]
+        log.debug("Geting with descriptor %s for %s"%(self.pred,obj.n3()))
         # check to see if this is a Container or Collection
         # if so, return collection as a list
@@ -173 +175 @@
                   val=getList(obj, self.pred)
         val=[(isinstance(v, (BNode,URIRef)) and self.range_class(v) or v.toPython()) for v in val]
-        # ?? FIXME why does the debug statement show up twice??
-        #setattr(obj, self.name, val) changed to next line 01/31/08  was calling twice
         obj.__dict__[self.name]= val
-        try:
-            log.debug("Geting %s for %s"%(obj.db.qname(self.pred),obj.db.qname(obj.resUri)))
-        except:
-            log.debug("Geting %s for %s"%(self.pred.n3(),obj.n3()))
         return val
 
@@ -201 +197 @@
         obj.__dict__[self.name] = copy(newvals)
         
+class rdfBest(rdfSingle):
+    '''This is a Discriptor  that returns one value that is the 
+    "best" result out of possible multiple matches
+    
+    returns a single value or None
+    
+    It is the responsibility of the select_fun to return a default
+    like choices[0] if no "Best" is found'''
+    
+    def __init__(self, pred, select_fun = None, cacheName=None, range_type=None ):
+        if select_fun:
+            self.select_fun = select_fun
+        super(rdfMultiple, self).__init__(pred, range_type)
+        
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        if self.name in obj.__dict__:
+            return obj.__dict__[self.name]
+        log.debug("Geting with descriptor %s for %s"%(self.pred,obj.n3()))
+        vals=[o for o in obj.db.objects(obj.resUri, self.pred)]
+        if vals:
+            val = self.select_fun(vals)
+            val = isinstance(val, (BNode,URIRef)) and self.range_class(val) or val.toPython()
+        else:
+            val = None
+        obj.__dict__[self.name]= val
+        return val
+
+class rdfLocale(rdfBest):
+    '''This is like rdfBest with a predefined select_fun to select 
+    from multiple choices like labels or comments and select the one
+    with the correct locale'''    
+    def __init__(self, pred, lang, cacheName=None):
+        self.lang = lang
+        cacheNameLang = cacheName or ("%s@%s" % (pred, lang))
+        super(rdfBest, self).__init__(pred,cacheName = cacheNameLang)
+
+    def select_fun(self, choices):
+        for x in choices:
+            if isinstance(x,Literal) and x.language==self.lang:
+                return x
+        return choices[0]
 
 class rdfList(rdfMultiple):
@@ -206 +245 @@
        Expects to return a list of values (could be a list of one)
        `__set__` will set the predicate as a RDF List'''
+       
     def __init__(self, pred, range_type=None):
         super(rdfMultiple, self).__init__(pred, range_type)
@@ -273 +313 @@
     '''This is a Discriptor    
        Expects to return a list of values (could be a list of one)
+       
+       container_type in `__init__` should be one of 
+
+               * rdf:Seq
+               * rdf:Bag
+               * rdf:Alt
+               
        `__set__` will set the predicate as a RDF Container type (defaults to rdf:Seq)'''
+
     def __init__(self, pred,  range_type=None, container_type="http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq"):
         super(rdfMultiple, self).__init__(pred,  range_type)
@@ -320 +368 @@
             obj.db.add((seq, RDF['_%i'%(i+1)], value2object(newvals[i])))
         obj.__dict__[self.name] = copy(newvals)
-
+        
+#################################################################################
+# More owl-ish and rdfs-ish descriptors
+
+class owlTransitive(rdfMultiple):
+    """owlTransitive is a descriptor based on a transitive predicate
+    The predicate should be of type owl:TransitiveProperty
+    """
+        
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        if self.name in obj.__dict__:
+            return obj.__dict__[self.name]
+        log.debug("Geting with descriptor %s for %s"%(self.pred,obj.n3()))
+        val=[self.range_class(o) for o in obj.db.transitive_objects(obj.resUri, self.pred)]
+        obj.__dict__[self.name]= val
+        return val

rdfalchemy/trunk/rdfalchemy/__init__.py

@@ -1 +1 @@
 from rdflib import URIRef, BNode, Namespace, RDF, RDFS
-from rdfalchemy.Literal import Literal
-from rdfalchemy.rdfSubject import rdfSubject
-from rdfalchemy.descriptors import *
+from Literal import Literal
+from rdfSubject import rdfSubject
+from descriptors import *
 
-from rdfalchemy.engine import create_engine, engine_from_config
+from engine import create_engine, engine_from_config
 
 __version__="0.2b2"

rdfalchemy/trunk/rdfalchemy/rdfsSubject.py

@@ -13 +13 @@
 """
 
-from rdfalchemy import rdfSubject, rdfSingle, rdfMultiple, RDF, RDFS, Namespace
-from rdfalchemy.orm import mapper, allsub
+from rdfalchemy import  rdfSubject, RDF, RDFS, Namespace
+from descriptors import *
+from orm import mapper, allsub
+
+from weakref import WeakValueDictionary
 import re
 
@@ -21 +24 @@
 _all_ = ['rdfsSubject','rdfsClass','rdfsProperty',
          'owlObjectProperty','owlDatatypeProperty',
+         'owlSymetricProperty', 'owlTransitiveProperty'       
          'owlFunctionalProperty','owlInverseFunctionalProperty']
 
@@ -28 +32 @@
 
 class rdfsSubject(rdfSubject):
+    __weakrefs = WeakValueDictionary()
     
     def _splitname(self):
@@ -84 +89 @@
         # this doesn't get the rdfsProperty subclasses
         # return list(rdfsProperty.filter_by(domain=self.resUri))
+        # TODO: why iterate all rdfsProperty subclasses
+        #       try self.db.subjects(RDFS.domain,self.resUri)
         return [x for x in rdfsProperty.ClassInstances() if x.domain == self]
+        
         
     
@@ -194 +202 @@
 class owlTransitiveProperty(owlObjectProperty):
     rdf_type = OWL.TransitiveProperty
-    default_descriptor = rdfMultiple
-        
+    default_descriptor = owlTransitive
     
 # this maps the return type of subClassOf back to rdfsClass

rdfalchemy/trunk/rdfalchemy/rdfSubject.py

@@ -132 +132 @@
             that is of type owl:InverseFunctional"""
         if len(kwargs) != 1:
-            raise ValueError("get_by wanted eaactly 1 but got  %i args\nMaybe you wanted filter_by"%(len(kwargs)))
+            raise ValueError("get_by wanted exactly 1 but got  %i args\nMaybe you wanted filter_by"%(len(kwargs)))
         key,value = kwargs.items()[0]
         if isinstance(value, URIRef) or isinstance(value,BNode) or isinstance(value,Literal):
@@ -195 +195 @@
     def GetRandom(cls):
         """for develoment just returns a random instance of this class"""
-        from random import randint
+        from random import choice
         xii=list(cls.ClassInstances())
-        return xii[randint(0,len(xii)-1)]
+        return choice(xii)
         
     def __repr__(self):

rdfalchemy/trunk/test/subclass_test.py

@@ -43 +43 @@
 
 def subclass_testLen1():
+    "Test these things that are just rdfSubject ... no inferencing"
     assert len(list(A.ClassInstances())) == 2
     assert len(list(B.ClassInstances())) == 2    
     
 def subclass_testLen2():
+    "Test these things that are just rdfSubject ... no inferencing"
     assert len(list(C.ClassInstances())) == 1
     assert len(list(D.ClassInstances())) == 3    
@@ -75 +77 @@
 
 def ssubclass_testLen1():
+    "Test these things that are rdfSSubject ... with inferencing"
     assert len(list(As.ClassInstances())) == 2, len(list(As.ClassInstances()))
     assert len(list(Bs.ClassInstances())) == 6, len(list(Bs.ClassInstances()))    
     
 def ssubclass_testLen2():
+    "Test these things that are rdfsSubject ... with inferencing"
     assert len(list(Cs.ClassInstances())) == 4, len(list(Cs.ClassInstances()))
     assert len(list(Ds.ClassInstances())) == 3, len(list(Ds.ClassInstances()))