Update app.py

app.py

@@ -260,130 +260,80 @@ def run_entity_exploration():
             max_distance=max_distance,
             include_classes=True
         )
-    elif not entities:
-        st.warning("No entities found in the ontology.")
-    
-    if selected_entity:
-        # Get entity information
-        entity_info = ontology_manager.get_entity_info(selected_entity)
-        
-        # Display detailed information
-        display_entity_details(entity_info, ontology_manager)
-        
-        # Set this entity as the central entity (for knowledge graph visualization)
-        if st.button("View this Entity in the Knowledge Graph"):
-            st.session_state.central_entity = selected_entity
-            st.rerun()
-        
-        # Get and display entity neighbors
-        st.subheader("Entity Neighborhood")
-        max_distance = st.slider("Maximum Neighborhood Distance", 1, 3, 1)
-        
-        neighborhood = knowledge_graph.get_entity_neighborhood(
-            selected_entity, 
-            max_distance=max_distance,
-            include_classes=True
-        )
-        
+
         if neighborhood and "neighbors" in neighborhood:
-            # Display neighbors grouped by distance
             for distance in range(1, max_distance+1):
                 neighbors_at_distance = [n for n in neighborhood["neighbors"] if n["distance"] == distance]
-                
+
                 if neighbors_at_distance:
                     with st.expander(f"Neighbors at Distance {distance} ({len(neighbors_at_distance)})"):
                         for neighbor in neighbors_at_distance:
                             st.markdown(f"**{neighbor['id']}** ({neighbor.get('class_type', 'unknown')})")
-                            
-                            # Display relations
                             for relation in neighbor.get("relations", []):
                                 direction = "→" if relation["direction"] == "outgoing" else "←"
                                 st.markdown(f"- {direction} {relation['type']}")
-                            
                             st.markdown("---")
 
-def run_semantic_path_visualization():
+    elif not entities:
+        st.warning("No entities found in the ontology.")
+
+def render_semantic_path_tab():
     st.title("Semantic Path Visualization")
-    
-    # Get all entities
-    entities = []
-    for class_name in ontology_manager.get_classes():
-        entities.extend(ontology_manager.get_instances_of_class(class_name))
-    
-    # Remove duplicates and sort
+
+    entities = [
+        node for node, attr in ontology_manager.graph.nodes(data=True)
+        if attr.get("type") == "instance"
+    ]
     entities = sorted(set(entities))
-    
-    # Create two columns for selecting source and target entities
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        source_entity = st.selectbox("Select Source Entity", entities, key="source")
-    
-    with col2:
-        target_entity = st.selectbox("Select Target Entity", entities, key="target")
-    
+
+    source_entity = st.selectbox("Select Source Entity", entities, key="source_entity") if entities else None
+    target_entity = st.selectbox("Select Target Entity", entities, key="target_entity") if entities else None
+
     if source_entity and target_entity and source_entity != target_entity:
-        # Provide a maximum path length option
         max_length = st.slider("Maximum Path Length", 1, 5, 3)
-        
-        # Find paths
+
         paths = knowledge_graph.find_paths_between_entities(
-            source_entity, 
+            source_entity,
             target_entity,
             max_length=max_length
         )
-        
+
         if paths:
             st.success(f"Found {len(paths)} paths!")
-            
-            # Create expanders for each path
             for i, path in enumerate(paths):
-                # Calculate path length and relationship types
                 path_length = len(path)
                 rel_types = [edge["type"] for edge in path]
-                
+
                 with st.expander(f"Path {i+1} (Length: {path_length}, Relations: {', '.join(rel_types)})", expanded=(i==0)):
-                    # Create a text description of the path
                     path_text = []
-                    entities_in_path = []
-                    
                     for edge in path:
                         source = edge["source"]
                         target = edge["target"]
                         relation = edge["type"]
-                        
-                        entities_in_path.append(source)
-                        entities_in_path.append(target)
-                        
-                        # Get entity information to get a readable name
+
                         source_info = ontology_manager.get_entity_info(source)
                         target_info = ontology_manager.get_entity_info(target)
-                        
-                        source_name = source
-                        if "properties" in source_info and "name" in source_info["properties"]:
-                            source_name = source_info["properties"]["name"]
-                        
-                        target_name = target
-                        if "properties" in target_info and "name" in target_info["properties"]:
-                            target_name = target_info["properties"]["name"]
-                        
+
+                        source_name = source_info.get("properties", {}).get("name", source)
+                        target_name = target_info.get("properties", {}).get("name", target)
+
                         path_text.append(f"{source_name} ({source}) **{relation}** {target_name} ({target})")
-                    
-                    # Display path description
+
                     st.markdown(" → ".join(path_text))
-                    
-                    # Prepare path visualization
+
                     path_info = {
                         "source": source_entity,
                         "target": target_entity,
                         "path": path,
                         "text": " → ".join(path_text)
                     }
-                    
-                    # Display path visualization
+
                     visualize_path(path_info, ontology_manager)
         else:
             st.warning(f"No paths of length {max_length} or shorter were found between these entities.")
+    elif not entities:
+        st.warning("No entities available for semantic path selection.")
+
 
 def run_reasoning_trace():
     st.title("Reasoning Trace Visualization")