Add comprehensive RDF debugging and improved property extraction - 2025-10-04 15:23:17

app.py

@@ -71,9 +71,32 @@ class BIBFRAMEKnowledgeBase:
                     format="xml"
                 )
             
-            # Extract properties - try multiple RDF property types
-            print("🔍 Looking for properties...")
+            # Debug: Let's see what's actually in the ontology
+            print("🔍 Analyzing ontology structure...")
+            
+            # Check what namespaces are used
+            namespaces = list(self.ontology_graph.namespaces())
+            print(f"🔍 Found namespaces: {[f'{prefix}: {ns}' for prefix, ns in namespaces[:5]]}")
+            
+            # Check what types are actually used
+            all_types = set()
+            for s, p, o in self.ontology_graph.triples((None, RDF.type, None)):
+                all_types.add(str(o))
+            print(f"🔍 Found types: {list(all_types)[:5]}...")
+            
+            # Try to find ALL properties regardless of type
+            print("🔍 Looking for all BIBFRAME properties...")
+            bf_subjects = set()
+            for subj in self.ontology_graph.subjects():
+                if str(subj).startswith(str(BF)):
+                    bf_subjects.add(subj)
+            
+            print(f"🔍 Found {len(bf_subjects)} BIBFRAME subjects total")
+            
+            # Extract properties - try multiple approaches
             property_types = [RDF.Property, RDFS.Property]
+            
+            # First, try standard property types
             for prop_type in property_types:
                 prop_count = 0
                 for prop in self.ontology_graph.subjects(RDF.type, prop_type):
@@ -90,6 +113,32 @@ class BIBFRAMEKnowledgeBase:
                         prop_count += 1
                 print(f"🔍 Found {prop_count} properties of type {prop_type}")
             
+            # Try to extract properties that have domain/range but no explicit type
+            print("🔍 Looking for properties with domain/range...")
+            domain_props = set()
+            for prop in self.ontology_graph.subjects(RDFS.domain, None):
+                if str(prop).startswith(str(BF)):
+                    domain_props.add(prop)
+                    
+            for prop in self.ontology_graph.subjects(RDFS.range, None):
+                if str(prop).startswith(str(BF)):
+                    domain_props.add(prop)
+                    
+            print(f"🔍 Found {len(domain_props)} properties with domain/range")
+            
+            # Add these as properties
+            for prop in domain_props:
+                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)
+                    }
+            
             # Also try owl:ObjectProperty and owl:DatatypeProperty
             from rdflib import OWL
             owl_property_types = [OWL.ObjectProperty, OWL.DatatypeProperty, OWL.AnnotationProperty]
@@ -111,6 +160,8 @@ class BIBFRAMEKnowledgeBase:
                     pass  # OWL might not be available
             
             # Extract classes
+            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), "")
@@ -120,9 +171,21 @@ class BIBFRAMEKnowledgeBase:
                         "definition": self._get_comment(cls),
                         "subClassOf": self._get_super_classes(cls)
                     }
+                    class_count += 1
+            print(f"🔍 Found {class_count} classes")
             
             self._loaded = True
-            print(f"✅ Loaded {len(self.properties)} properties and {len(self.classes)} classes")
+            total_props = len(self.properties)
+            total_classes = len(self.classes)
+            print(f"✅ Loaded {total_props} properties and {total_classes} classes from ontology")
+            
+            # If we didn't find any properties, something went wrong
+            if total_props == 0 and total_classes == 0:
+                print("⚠️ No properties or classes found - this seems wrong!")
+                print("📦 Adding minimal fallback data...")
+                self._load_minimal_fallback()
+            else:
+                print("🎉 Successfully loaded BIBFRAME ontology data!")
             
         except Exception as e:
             print(f"⚠️ Error loading ontology: {e}")
@@ -132,7 +195,9 @@ class BIBFRAMEKnowledgeBase:
     
     def _load_minimal_fallback(self):
         """Minimal fallback data if ontology loading fails"""
-        self.properties = {
+        # Don't overwrite existing data
+        if not self.properties:
+            self.properties = {
             "bf:assigner": {
                 "uri": "http://id.loc.gov/ontologies/bibframe/assigner",
                 "label": "Assigner",
@@ -149,9 +214,10 @@ class BIBFRAMEKnowledgeBase:
                 "range": ["http://id.loc.gov/ontologies/bibframe/Title"],
                 "subPropertyOf": []
             }
-        }
+            }
         
-        self.classes = {
+        if not self.classes:
+            self.classes = {
             "bf:Work": {
                 "uri": "http://id.loc.gov/ontologies/bibframe/Work",
                 "label": "Work",
@@ -164,10 +230,10 @@ class BIBFRAMEKnowledgeBase:
                 "definition": "Individual exemplar of a Work",
                 "subClassOf": ["http://id.loc.gov/ontologies/bibframe/Resource"]
             }
-        }
+            }
         
         self._loaded = True
-        print("📦 Loaded fallback data: 2 properties, 2 classes")
+        print(f"📦 Loaded fallback data: {len(self.properties)} properties, {len(self.classes)} classes")
     
     def _get_label(self, resource):
         return str(self.ontology_graph.value(resource, RDFS.label) or "")