rdf:Resource can be either a resource or a blank node.

[htsworkflow.git] / htsworkflow / util / rdfinfer.py

diff --git a/htsworkflow/util/rdfinfer.py b/htsworkflow/util/rdfinfer.py
index 8f12f5c6e4e27761087cbe2346207f5b3b65e7e9..1a0fb504181cdf4aed6ebf2aadf68271efbb5bb1 100644 (file)
--- a/htsworkflow/util/rdfinfer.py
+++ b/htsworkflow/util/rdfinfer.py
@@ -8,6 +8,7 @@ from htsworkflow.util.rdfns import *
 from htsworkflow.util.rdfhelp import SCHEMAS_URL
 
 INFER_URL='http://jumpgate.caltech.edu/phony/infer'
+LOGGER = logging.getLogger(__name__)
 
 class Infer(object):
     """Provide some simple inference.
@@ -36,6 +37,7 @@ class Infer(object):
 
             for method_name in dir(self):
                 if method_name.startswith('_rule_'):
+                    LOGGER.info("Running: %s", method_name)
                     method = getattr(self, method_name)
                     method()
             if self.model.size() == starting_size:
@@ -55,11 +57,11 @@ class Infer(object):
         """
         for method_name in dir(self):
             if method_name.startswith('_validate_'):
+                LOGGER.info("Running: %s", method_name)
                 method = getattr(self, method_name)
                 for msg in method():
                     yield msg
 
-
     def _rule_class(self):
         """resolve class chains.
         e.g. if a is an BClass, and a BClass is an AClass
@@ -180,8 +182,50 @@ class Infer(object):
                         {space} ?type .
         }}"""
 
-        wrong_domain_type = "Domain of {0} was not {1}"
-        wrong_range_type = "Range of {0} was not {1}"
+        def check_node_space(node, predicate, space, errmsg):
+            """Check that a node conforms to it's allowable space of types.
+
+            e.g. is a subject (node) the domain (space) of this property
+            and is the object (node) the range of of this property.
+            """
+            resource_error = "Expected resource for {0} in range {1}"
+            type_error = "Type of {0} was {1} not {2}"
+            # check domain
+            query = RDF.SPARQLQuery(property_template.format(
+                predicate=predicate.uri,
+                space=space))
+            seen = set()
+            for r in query.execute(self.model):
+                # Make sure we have a resource if we're expecting one
+                if r['type'] == rdfsNS['Resource']:
+                    if node.is_literal():
+                        return resource_error.format(str(node), space)
+                    continue
+                seen.add(str(r['type'].uri))
+                if node.is_literal():
+                    # literal is a generic type.
+                    nodetype = node.literal_value['datatype']
+                    if nodetype is None:
+                        # lets default to string
+                        nodetype = xsdNS['string'].uri
+                    if r['type'] == rdfsNS['Literal']:
+                        pass
+                    elif nodetype != r['type'].uri:
+                        return type_error.format(
+                            str(node), nodetype, r['type'])
+                # check that node is the expetected class type
+                check = RDF.Statement(node, rdfNS['type'], r['type'])
+                if self.model.contains_statement(check):
+                    return
+
+            # need the seen check, because we're surpressing checking
+            # rdfs:Resource types
+            if len(seen) > 0:
+                return errmsg + ",".join(seen)
+
+
+        wrong_domain_type = "Domain of {0} was not in:"
+        wrong_range_type = "Range of {0} was not in:"
 
         count = 0
         schema = RDF.Node(RDF.Uri(SCHEMAS_URL))
@@ -189,27 +233,11 @@ class Infer(object):
             if context == schema:
                 continue
             # check domain
-            query = RDF.SPARQLQuery(property_template.format(
-                predicate=s.predicate,
-                space='rdfs:domain'))
-            for r in query.execute(self.model):
-                if r['type'] == rdfsNS['Resource']:
-                    continue
-                check = RDF.Statement(s.subject, rdfNS['type'], r['type'])
-                if not self.model.contains_statement(check):
-                    yield wrong_domain_type.format(str(s),
-                                                   str(r['type']))
+            msg = check_node_space(s.subject, s.predicate, 'rdfs:domain',
+                                   wrong_domain_type.format(str(s)))
+            if msg is not None: yield msg
             # check range
-            query = RDF.SPARQLQuery(property_template.format(
-                predicate=s.predicate,
-                space='rdfs:range'))
-            for r in query.execute(self.model):
-                if r['type'] == rdfsNS['Resource']:
-                    continue
-                check = RDF.Statement(s.object, rdfNS['type'], r['type'])
-                if not self.model.contains_statement(check):
-                    yield wrong_range_type.format(str(s),
-                                                  str(r['type']))
-
+            msg = check_node_space(s.object, s.predicate, 'rdfs:range',
+                                   wrong_range_type.format(str(s)))
+            if msg is not None: yield msg
         return
-