Fix RDF property extraction: use OWL property types instead of invalid RDFS.Property - 2025-10-04 15:27:47

app.py

@@ -16,7 +16,7 @@ import gradio as gr
 import json
 import requests
 from typing import Dict, List, Optional, Any
-from rdflib import Graph, URIRef, Literal, Namespace, RDFS, RDF
+from rdflib import Graph, URIRef, Literal, Namespace, RDFS, RDF, OWL
 from functools import lru_cache
 import re
 
@@ -93,27 +93,33 @@ class BIBFRAMEKnowledgeBase:
             
             print(f"🔍 Found {len(bf_subjects)} BIBFRAME subjects total")
             
-            # Extract properties - try multiple approaches
-            property_types = [RDF.Property, RDFS.Property]
+            # Extract properties using OWL property types (BIBFRAME uses OWL, not RDFS)
+            print("🔍 Extracting OWL properties...")
+            owl_property_types = [
+                (OWL.ObjectProperty, "ObjectProperty"),
+                (OWL.DatatypeProperty, "DatatypeProperty"),
+                (OWL.AnnotationProperty, "AnnotationProperty"),
+                (RDF.Property, "RDF.Property")
+            ]
             
-            # First, try standard property types
-            for prop_type in property_types:
+            for prop_type, type_name in owl_property_types:
                 prop_count = 0
                 for prop in self.ontology_graph.subjects(RDF.type, prop_type):
                     if str(prop).startswith(str(BF)):
                         local_name = str(prop).replace(str(BF), "")
-                        self.properties[f"bf:{local_name}"] = {
-                            "uri": str(prop),
-                            "label": self._get_label(prop),
-                            "definition": self._get_comment(prop),
-                            "domain": self._get_domains(prop),
-                            "range": self._get_ranges(prop),
-                            "subPropertyOf": self._get_super_properties(prop)
-                        }
-                        prop_count += 1
-                print(f"🔍 Found {prop_count} properties of type {prop_type}")
+                        if f"bf:{local_name}" not in self.properties:
+                            self.properties[f"bf:{local_name}"] = {
+                                "uri": str(prop),
+                                "label": self._get_label(prop),
+                                "definition": self._get_comment(prop),
+                                "domain": self._get_domains(prop),
+                                "range": self._get_ranges(prop),
+                                "subPropertyOf": self._get_super_properties(prop)
+                            }
+                            prop_count += 1
+                print(f"🔍 Found {prop_count} properties of type {type_name}")
             
-            # Try to extract properties that have domain/range but no explicit type
+            # Also extract properties that have domain/range but might not have explicit type
             print("🔍 Looking for properties with domain/range...")
             domain_props = set()
             for prop in self.ontology_graph.subjects(RDFS.domain, None):
@@ -139,40 +145,24 @@ class BIBFRAMEKnowledgeBase:
                         "subPropertyOf": self._get_super_properties(prop)
                     }
             
-            # Also try owl:ObjectProperty and owl:DatatypeProperty
-            from rdflib import OWL
-            owl_property_types = [OWL.ObjectProperty, OWL.DatatypeProperty, OWL.AnnotationProperty]
-            for prop_type in owl_property_types:
-                try:
-                    for prop in self.ontology_graph.subjects(RDF.type, prop_type):
-                        if str(prop).startswith(str(BF)):
-                            local_name = str(prop).replace(str(BF), "")
-                            if f"bf:{local_name}" not in self.properties:
-                                self.properties[f"bf:{local_name}"] = {
-                                    "uri": str(prop),
-                                    "label": self._get_label(prop),
-                                    "definition": self._get_comment(prop),
-                                    "domain": self._get_domains(prop),
-                                    "range": self._get_ranges(prop),
-                                    "subPropertyOf": self._get_super_properties(prop)
-                                }
-                except:
-                    pass  # OWL might not be available
-            
-            # Extract classes
+            # Extract classes (try both OWL.Class and RDFS.Class)
             print("🔍 Looking for classes...")
-            class_count = 0
-            for cls in self.ontology_graph.subjects(RDF.type, RDFS.Class):
-                if str(cls).startswith(str(BF)):
-                    local_name = str(cls).replace(str(BF), "")
-                    self.classes[f"bf:{local_name}"] = {
-                        "uri": str(cls),
-                        "label": self._get_label(cls),
-                        "definition": self._get_comment(cls),
-                        "subClassOf": self._get_super_classes(cls)
-                    }
-                    class_count += 1
-            print(f"🔍 Found {class_count} classes")
+            class_types = [(OWL.Class, "OWL.Class"), (RDFS.Class, "RDFS.Class")]
+            
+            for class_type, type_name in class_types:
+                class_count = 0
+                for cls in self.ontology_graph.subjects(RDF.type, class_type):
+                    if str(cls).startswith(str(BF)):
+                        local_name = str(cls).replace(str(BF), "")
+                        if f"bf:{local_name}" not in self.classes:
+                            self.classes[f"bf:{local_name}"] = {
+                                "uri": str(cls),
+                                "label": self._get_label(cls),
+                                "definition": self._get_comment(cls),
+                                "subClassOf": self._get_super_classes(cls)
+                            }
+                            class_count += 1
+                print(f"🔍 Found {class_count} classes of type {type_name}")
             
             self._loaded = True
             total_props = len(self.properties)