better graph

app.py

@@ -2,8 +2,11 @@ import streamlit as st
 import asyncio
 import websockets
 import json
-import platform
-from typing import Dict, Any, Optional, List, Literal, TypedDict, cast
+import tempfile
+import os
+from typing import Dict, Any, Optional, List, Literal, TypedDict, cast, Set, Tuple
+from streamlit_agraph import agraph, Node, Edge, Config
+import pyvis.network as net
 
 GGRAPHER_URI = "wss://ggrphr.davidalber.net"
 
@@ -63,7 +66,190 @@ async def get_graph(payload: RequestPayload, progress_cb=None) -> Dict[str, Any]
             else:
                 continue
 
+def build_tree_structure(graph: Dict[str, Any], root_id: int) -> Dict[int, Dict[str, Any]]:
+    """Build a hierarchical tree structure from the graph data."""
+    nodes = graph.get("nodes", {})
+    tree = {}
+    
+    # calculate depth/generation for each node
+    def calculate_depths(node_id: int, visited: Set[int], depth: int = 0) -> Dict[int, int]:
+        if node_id in visited:
+            return {}
+        
+        visited.add(node_id)
+        depths = {node_id: depth}
+        
+        node = nodes.get(node_id, {})
+        for advisor_id in node.get("advisors", []):
+            if advisor_id in nodes:
+                advisor_depths = calculate_depths(advisor_id, visited, depth + 1)
+                depths.update(advisor_depths)
+        
+        return depths
+    
+    depths = calculate_depths(root_id, set())
+    
+    # build tree structure with depth info
+    for node_id, node in nodes.items():
+        if node_id in depths:
+            tree[node_id] = {
+                **node,
+                "depth": depths[node_id],
+                "children": [],
+                "advisors": node.get("advisors", [])
+            }
+    
+    # establish parent-child relationships
+    for node_id, node in tree.items():
+        for advisor_id in node["advisors"]:
+            if advisor_id in tree:
+                tree[advisor_id]["children"].append(node_id)
+    
+    return tree
+
+def create_hierarchical_view(graph: Dict[str, Any], root_id: int, max_depth: int = None) -> Tuple[List[Node], List[Edge]]:
+    """Create nodes and edges for hierarchical tree view."""
+    tree = build_tree_structure(graph, root_id)
+    nodes_list = []
+    edges_list = []
+    
+    # color scheme by generation
+    colors = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#96ceb4", "#feca57", "#ff9ff3", "#54a0ff"]
+    
+    # group nodes by depth for positioning
+    nodes_by_depth = {}
+    for node_id, node in tree.items():
+        if max_depth is None or node["depth"] <= max_depth:
+            depth = node["depth"]
+            if depth not in nodes_by_depth:
+                nodes_by_depth[depth] = []
+            nodes_by_depth[depth].append((node_id, node))
+    
+    # sort nodes within each depth by year (oldest first, recent last for lower position)
+    for depth in nodes_by_depth:
+        nodes_by_depth[depth].sort(key=lambda x: x[1].get('year') or 1400)
+    
+    # create nodes with positioning hints
+    for depth in sorted(nodes_by_depth.keys()):
+        depth_nodes = nodes_by_depth[depth]
+        
+        for i, (node_id, node) in enumerate(depth_nodes):
+            color = colors[depth % len(colors)]
+            
+            name = node.get("name", str(node_id))
+            year_str = f" ({node.get('year')})" if node.get('year') is not None else ""
+            label = f"{name}{year_str}"
+            
+            # calculate positioning based on year within generation
+            year = node.get('year') or 1500  # default to old year if missing
+            base_y = depth * 300  # spacing between generations
+            
+            # position nodes with year-based offset within generation
+            # more recent years get higher y values (appear lower on screen)
+            year_offset = (year - 1400) * 0.2  # scale factor for year spacing
+            x_pos = i * 180 + (depth * 20)  # slight x offset per depth to avoid overlap
+            y_pos = base_y + year_offset
+            
+            # create streamlit-agraph node with positioning
+            ag_node = Node(
+                id=str(node_id),
+                label=label,
+                size=25 if node_id == root_id else 20,
+                color=color,
+                title=f"Name: {name}\nYear: {node.get('year', 'N/A')}\nInstitution: {node.get('institution', 'N/A')}",
+                x=x_pos,
+                y=y_pos
+            )
+            nodes_list.append(ag_node)
+            
+            # create edges to advisors
+            for advisor_id in node["advisors"]:
+                if advisor_id in tree and (max_depth is None or tree[advisor_id]["depth"] <= max_depth):
+                    edge = Edge(
+                        source=str(advisor_id),
+                        target=str(node_id),
+                        color="#666666"
+                    )
+                    edges_list.append(edge)
+    
+    return nodes_list, edges_list
+
+def create_pyvis_network(graph: Dict[str, Any], root_id: int) -> str:
+    """Create an interactive network using pyvis."""
+    nodes = graph.get("nodes", {})
+    
+    # create network
+    nt = net.Network(
+        height="600px",
+        width="100%",
+        bgcolor="#ffffff",
+        font_color="black",
+        directed=True
+    )
+    
+    # configure physics
+    nt.set_options("""
+    var options = {
+      "physics": {
+        "enabled": true,
+        "hierarchicalRepulsion": {
+          "centralGravity": 0.3,
+          "springLength": 120,
+          "springConstant": 0.01,
+          "nodeDistance": 200,
+          "damping": 0.09
+        },
+        "solver": "hierarchicalRepulsion"
+      },
+      "layout": {
+        "hierarchical": {
+          "enabled": true,
+          "direction": "UD",
+          "sortMethod": "directed"
+        }
+      }
+    }
+    """)
+    
+    # calculate depths for coloring
+    tree = build_tree_structure(graph, root_id)
+    colors = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#96ceb4", "#feca57", "#ff9ff3", "#54a0ff"]
+    
+    # add nodes
+    for node_id, node in nodes.items():
+        name = node.get("name", str(node_id))
+        year_str = f" ({node.get('year')})" if node.get('year') is not None else ""
+        label = f"{name}{year_str}"
+        
+        depth = tree.get(node_id, {}).get("depth", 0)
+        color = colors[depth % len(colors)]
+        
+        nt.add_node(
+            node_id,
+            label=label,
+            title=f"Name: {name}\nYear: {node.get('year', 'N/A')}\nInstitution: {node.get('institution', 'N/A')}",
+            color=color,
+            size=30 if node_id == root_id else 20
+        )
+    
+    # add edges
+    for node_id, node in nodes.items():
+        for advisor_id in node.get("advisors", []):
+            if advisor_id in nodes:
+                nt.add_edge(advisor_id, node_id)
+    
+    # save to temp file
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".html")
+    nt.save_graph(temp_file.name)
+    
+    with open(temp_file.name, 'r') as f:
+        html_content = f.read()
+    
+    os.unlink(temp_file.name)
+    return html_content
+
 def tree_to_dot(graph: Dict[str, Any]) -> str:
+    """Original graphviz DOT format (kept as fallback)."""
     nodes = graph.get("nodes", {})
     lines = [
         "digraph G {",
@@ -71,24 +257,52 @@ def tree_to_dot(graph: Dict[str, Any]) -> str:
         '  node [shape=box, style="rounded,filled", fillcolor=lightyellow];',
         '  edge [arrowhead=vee];'
     ]
-    # Define nodes and their labels
+    
     for node_id, node in nodes.items():
         name = node.get("name", str(node_id))
         year_str = f" ({node.get('year')})" if node.get('year') is not None else " (Year Unknown)"
         label = f"{name}{year_str}"
         tooltip = f"ID: {node_id}\\nName: {name}\\nYear: {node.get('year', 'N/A')}\\nInstitution: {node.get('institution', 'N/A')}"
         lines.append(f'  "{node_id}" [label="{label}", tooltip="{tooltip}"];')
-    # Define edges
+    
     for node_id, node in nodes.items():
         for adv_id in node.get("advisors", []):
             if adv_id in nodes:
                 lines.append(f'  "{adv_id}" -> "{node_id}";')
+    
     lines.append("}")
     return "\n".join(lines)
 
+def display_tree_summary(graph: Dict[str, Any], root_id: int):
+    """Display summary statistics about the tree."""
+    tree = build_tree_structure(graph, root_id)
+    
+    if not tree:
+        return
+    
+    max_depth = max(node["depth"] for node in tree.values()) if tree else 0
+    total_nodes = len(tree)
+    
+    # count nodes by generation
+    depth_counts = {}
+    for node in tree.values():
+        depth = node["depth"]
+        depth_counts[depth] = depth_counts.get(depth, 0) + 1
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Total Mathematicians", total_nodes)
+    with col2:
+        st.metric("Generations Back", max_depth)
+    with col3:
+        root_name = tree.get(root_id, {}).get("name", "Unknown")
+        st.metric("Root", root_name)
+    
+
 def main():
     st.title("Math Genealogy Ancestor Tree")
-
+    st.write("Interactive visualization of academic advisor relationships from the Mathematics Genealogy Project")
+    
     mathematicians = [
         ("Tristan Hearn", 162833),
         ("Alexander Grothendieck", 31245),
@@ -100,13 +314,19 @@ def main():
     names = [f"{name} ({mid})" for name, mid in mathematicians]
     default_index = 0  # Tristan Hearn
 
-    # initialize session state for mgp_id_str if not set
+    # initialize session state
     if "mgp_id_str" not in st.session_state:
         st.session_state["mgp_id_str"] = str(mathematicians[default_index][1])
+    if "graph_data" not in st.session_state:
+        st.session_state["graph_data"] = None
+    if "root_id" not in st.session_state:
+        st.session_state["root_id"] = None
 
+    # input section
+    st.subheader("Select Mathematician")
+    
     mgp_id_str = st.text_input(
         "Enter MGP ID (integer):",
-        value=st.session_state["mgp_id_str"],
         key="mgp_id_str",
         help="You can type a custom ID or use the selection below."
     )
@@ -124,30 +344,136 @@ def main():
     )
 
     progress_placeholder = st.empty()
-    graph_placeholder = st.empty()
-    run_btn = st.button("Show Ancestor Tree")
+    
+    # fetch data
+    run_btn = st.button("Fetch Ancestor Tree", type="primary")
     if run_btn:
         mgp_id = get_id_from_input(st.session_state["mgp_id_str"])
         if mgp_id is None:
             st.error("Please enter a valid integer MGP ID.")
             return
+        
         payload = make_payload(mgp_id)
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
+        
         def progress_cb(progress):
             progress_placeholder.info(
                 f"Queued: {progress['queued']} | Fetching: {progress['fetching']} | Done: {progress['done']}"
             )
+        
         async def runner():
             graph = await get_graph(payload, progress_cb)
-            dot = tree_to_dot(graph)
-            graph_placeholder.graphviz_chart(dot)
+            st.session_state["graph_data"] = graph
+            st.session_state["root_id"] = mgp_id
+        
         try:
             loop.run_until_complete(runner())
-            progress_placeholder.success("Done!")
+            progress_placeholder.success("Data fetched successfully!")
         except Exception as e:
             print(f"Error: {e}")
             progress_placeholder.error(f"Error: {e}")
+            return
+
+    # display visualizations if data is available
+    if st.session_state["graph_data"] is not None:
+        graph = st.session_state["graph_data"]
+        root_id = st.session_state["root_id"]
+        
+        st.divider()
+        
+        # show summary
+        display_tree_summary(graph, root_id)
+        
+        st.divider()
+        
+        # visualization options
+        st.subheader("Choose Visualization")
+        
+        viz_option = st.radio(
+            "Select visualization type:",
+            ["Interactive Hierarchical Tree", "Interactive Network", "Traditional Graph (Graphviz)"],
+            help="Different views for exploring the genealogy tree"
+        )
+        
+        if viz_option == "Interactive Hierarchical Tree":
+            st.write("**Hierarchical Tree View** - Best for exploring direct lineages")
+            
+            # depth filter
+            tree = build_tree_structure(graph, root_id)
+            max_available_depth = max(node["depth"] for node in tree.values()) if tree else 0
+            
+            if max_available_depth > 0:
+                depth_filter = st.slider(
+                    "Show generations back:",
+                    min_value=0,
+                    max_value=max_available_depth,
+                    value=min(3, max_available_depth),
+                    help="Limit the number of generations to display for better readability"
+                )
+            else:
+                depth_filter = 0
+            
+            # create hierarchical view
+            nodes_list, edges_list = create_hierarchical_view(graph, root_id, depth_filter)
+            
+            if nodes_list:
+                config = Config(
+                    width=800,
+                    height=600,
+                    directed=True,
+                    physics=True,
+                    hierarchical=True,
+                    nodeHighlightBehavior=True,
+                    highlightColor="#F7A7A6",
+                    collapsible=False
+                )
+                
+                agraph(nodes=nodes_list, edges=edges_list, config=config)
+            else:
+                st.warning("No data to display with current filters.")
+        
+        elif viz_option == "Interactive Network":
+            st.write("**Interactive Network View** - Explore with zoom, pan, and physics simulation")
+            
+            with st.spinner("Generating interactive network..."):
+                html_content = create_pyvis_network(graph, root_id)
+                st.components.v1.html(html_content, height=650)
+        
+        else:  # Traditional Graph
+            st.write("**Traditional Graph View** - Standard graphviz layout")
+            dot = tree_to_dot(graph)
+            st.graphviz_chart(dot)
+        
+        # search functionality
+        st.divider()
+        st.subheader("Search Mathematicians")
+        
+        nodes = graph.get("nodes", {})
+        search_term = st.text_input("Search by name:", placeholder="e.g., Gauss, Euler, Newton")
+        
+        if search_term:
+            matches = []
+            for node_id, node in nodes.items():
+                name = node.get("name", "")
+                if search_term.lower() in name.lower():
+                    year = node.get("year", "N/A")
+                    institution = node.get("institution", "N/A")
+                    matches.append({
+                        "id": node_id,
+                        "name": name,
+                        "year": year,
+                        "institution": institution
+                    })
+            
+            if matches:
+                st.write(f"Found {len(matches)} match(es):")
+                for match in matches[:10]:  # limit to 10 results
+                    st.write(f"• **{match['name']}** ({match['year']}) - {match['institution']} (ID: {match['id']})")
+                if len(matches) > 10:
+                    st.write(f"... and {len(matches) - 10} more")
+            else:
+                st.write("No matches found.")
 
 if __name__ == "__main__":
     main()

pyproject.toml

@@ -11,6 +11,8 @@ python = ">=3.9,<3.9.7 || >3.9.7,<4.0"
 streamlit = "^1.35.0"
 aiohttp = "^3.12.0"
 beautifulsoup4 = "^4.13.4"
+streamlit-agraph = "^0.0.45"
+pyvis = "^0.3.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.2.0"