edge and node size reflect popularity

app.py

@@ -3,6 +3,7 @@ import networkx as nx
 from pyvis.network import Network
 import pickle
 import math
+import random
 
 # Dictionary to map brands to their respective pickle files
 BRAND_GRAPHS = {
@@ -16,10 +17,6 @@ BRAND_GRAPHS = {
 def load_graph(brand):
     """
     Load the graph for the selected brand.
-    Parameters:
-        brand (str): The brand name corresponding to the graph to load.
-    Returns:
-        nx.DiGraph: The loaded graph.
     """
     with open(BRAND_GRAPHS[brand], 'rb') as f:
         return pickle.load(f)
@@ -27,32 +24,21 @@ def load_graph(brand):
 def filter_graph(graph, node_threshold=10, edge_threshold=5):
     """
     Filters the graph to include only popular nodes and edges.
-
-    Parameters:
-        graph (nx.DiGraph): The original graph.
-        node_threshold (int): Minimum degree for a node to be included.
-        edge_threshold (int): Minimum weight for an edge to be included.
-
-    Returns:
-        nx.DiGraph: A filtered graph with popular nodes and edges.
     """
-    # Identify popular nodes based on their degree
     popular_nodes = [
         node for node in graph.nodes
         if graph.degree(node) >= node_threshold
     ]
 
-    # Create a subgraph with only popular nodes
     filtered_graph = graph.subgraph(popular_nodes).copy()
 
-    # Remove edges that don't meet the weight threshold
     for u, v, data in list(filtered_graph.edges(data=True)):
         if data.get("weight", 0) < edge_threshold:
             filtered_graph.remove_edge(u, v)
 
     return filtered_graph
 
-def dynamic_visualize_graph(graph, start_node, layers=3, top_k=5):
+def dynamic_visualize_graph(graph, start_node, layers=3, top_k=5, show_titles=False):
     net = Network(notebook=False, width="100%", height="600px", directed=True)
     net.set_options("""
     var options = {
@@ -66,12 +52,22 @@ def dynamic_visualize_graph(graph, start_node, layers=3, top_k=5):
     """)
 
     visited_nodes = set()
-    added_edges = set()  # Track edges to avoid duplicates
-    current_nodes = [int(start_node)]  # Convert start_node to int
+    added_edges = set()
+    current_nodes = [int(start_node)]
 
     # Add the starting node, color it red, and include a tooltip
-    start_title = graph.nodes[int(start_node)].get('title', 'No title available')  # Get the title attribute
-    net.add_node(int(start_node), label=str(start_node), color="red", title=start_title)
+    start_title = graph.nodes[int(start_node)].get('title', 'No title available')
+    start_in_degree = graph.in_degree(int(start_node))
+    start_out_degree = graph.out_degree(int(start_node))
+    start_node_size = (start_in_degree + start_out_degree) * 0.15
+    label = str(start_node) if not show_titles else f"{str(start_node)}: {start_title[:15]}..."  # Adjust title length
+    net.add_node(
+        int(start_node),
+        label=label,
+        color="darkblue",
+        title=f"{start_title} In-degree: {start_in_degree}, Out-degree: {start_out_degree}",
+        size=start_node_size
+    )
     visited_nodes.add(int(start_node))
 
     for layer in range(layers):
@@ -81,75 +77,58 @@ def dynamic_visualize_graph(graph, start_node, layers=3, top_k=5):
                 [(int(neighbor), data['weight']) for neighbor, data in graph[node].items()],
                 key=lambda x: x[1],
                 reverse=True
-            )[:top_k]  # Get top_k neighbors for this node
+            )[:top_k]
 
             for neighbor, weight in neighbors:
                 if neighbor not in visited_nodes:
-                    neighbor_title = graph.nodes[neighbor].get('title', 'No title available')  # Get tooltip
-                    net.add_node(neighbor, label=str(neighbor), title=neighbor_title)  # Add node with tooltip
-                edge = (node, neighbor)  # Represent the edge as a tuple
+                    neighbor_title = graph.nodes[neighbor].get('title', 'No title available')
+                    neighbor_in_degree = graph.in_degree(neighbor)
+                    neighbor_out_degree = graph.out_degree(neighbor)
+                    neighbor_size = (neighbor_in_degree + neighbor_out_degree) * 0.15
+                    node_color = 'red' if neighbor_in_degree > neighbor_out_degree * 1.5 else \
+                                 'green' if neighbor_out_degree > neighbor_in_degree * 1.5 else 'lightblue'
+                    label = str(neighbor) if not show_titles else f"{str(neighbor)}: {neighbor_title[:15]}..."
+                    net.add_node(
+                        neighbor,
+                        label=label,
+                        title=f"{neighbor_title} In-degree: {neighbor_in_degree}, Out-degree: {neighbor_out_degree}",
+                        size=neighbor_size,
+                        color=node_color
+                    )
+                edge = (node, neighbor)
                 if edge not in added_edges:
-                    net.add_edge(node, neighbor, label=f"w:{weight}")  # Add the edge only if not already added
-                    added_edges.add(edge)  # Track this edge as added
+                    edge_width = math.log(weight + 1) * 8
+                    net.add_edge(node, neighbor, label=f"w:{weight}", width=edge_width, color='lightblue')
+                    added_edges.add(edge)
                 visited_nodes.add(neighbor)
-                next_nodes.append(neighbor)  # Always add to next_nodes for further expansion
+                next_nodes.append(neighbor)
 
-        current_nodes = next_nodes  # Move to the next layer
+        current_nodes = next_nodes
 
-    # Generate the final visualization
     html_content = net.generate_html()
     st.components.v1.html(html_content, height=600, scrolling=False)
 
 
-def display_node_info(graph, node_id):
-    """
-    Display all attributes of a node and its edges in the graph.
-
-    Parameters:
-        graph (nx.DiGraph): The graph containing the node.
-        node_id (int or str): The ID of the node to inspect.
-
-    Returns:
-        None
-    """
-    if node_id not in graph:
-        print(f"Node {node_id} does not exist in the graph.")
-        return
-
-    # Display node attributes
-    print(f"Attributes of node {node_id}:")
-    for attr, value in graph.nodes[node_id].items():
-        print(f"  {attr}: {value}")
-
-    # Display incoming edges
-    print(f"\nIncoming edges to node {node_id}:")
-    for u, v, data in graph.in_edges(node_id, data=True):
-        print(f"  From {u} to {v} with attributes: {data}")
-
-    # Display outgoing edges
-    print(f"\nOutgoing edges from node {node_id}:")
-    for u, v, data in graph.out_edges(node_id, data=True):
-        print(f"  From {u} to {v} with attributes: {data}")
-
-
-# Streamlit interface
-st.title("Interactive Graph Expansion with Tooltips")
+st.title("Interactive Graph Expansion with Toggle for Content Titles")
 
 # Brand Selection
 selected_brand = st.selectbox("Select a brand:", options=list(BRAND_GRAPHS.keys()))
 
-import random
-
-# Check if the brand has changed
 if "selected_brand" not in st.session_state or st.session_state.selected_brand != selected_brand:
-    # Load the new graph and reset the start node
     st.session_state.selected_brand = selected_brand
     G = load_graph(selected_brand)
-    st.session_state.start_node = random.choice(list(G.nodes))
+
+    # Sort nodes by popularity (in-degree + out-degree) and select from top 20
+    popular_nodes = sorted(G.nodes, key=lambda n: G.in_degree(n) + G.out_degree(n), reverse=True)
+    top_20_nodes = popular_nodes[:20] if len(popular_nodes) > 20 else popular_nodes
+    st.session_state.start_node = random.choice(top_20_nodes)
 else:
-    # Use the existing graph
     G = load_graph(selected_brand)
 
+# Random Selection Button
+if st.button("Random Selection"):
+    st.session_state.start_node = random.choice(list(G.nodes))
+
 # Input: Starting node
 start_node = st.number_input(
     "Enter the starting node ID:",
@@ -157,17 +136,19 @@ start_node = st.number_input(
     step=1
 )
 
-# Filter the graph for popular nodes and edges
-node_degree_threshold = 1  # Minimum degree for nodes
-edge_weight_threshold = 1   # Minimum weight for edges
+# Toggle for showing content titles
+show_titles = st.checkbox("Show content titles", value=False)
+
+# Filter the graph
+node_degree_threshold = 1
+edge_weight_threshold = 1
 G_filtered = filter_graph(G, node_threshold=node_degree_threshold, edge_threshold=edge_weight_threshold)
 
 layers = st.slider("Depth to explore:", 1, 6, value=3)
 top_k = st.slider("Branching factor (per node):", 1, 6, value=3)
 
-# Trigger the visualization
 if st.button("Expand Graph"):
     if start_node in G_filtered:
-        dynamic_visualize_graph(G_filtered, start_node, layers=layers, top_k=top_k)
+        dynamic_visualize_graph(G_filtered, start_node, layers=layers, top_k=top_k, show_titles=show_titles)
     else:
         st.error("The starting node is not in the graph!")