Update app.py

app.py

@@ -1,14 +1,13 @@
 import streamlit as st
-import matplotlib.pyplot as plt
 import networkx as nx
-import bz2
+import matplotlib.pyplot as plt
 
 # Sidebar for selecting an option
 sidebar_option = st.sidebar.radio("Select an option", 
                                  ["Select an option", "Basic: Properties", 
                                   "Basic: Read and write graphs", "Basic: Simple graph", 
                                   "Basic: Simple graph Directed", "Drawing: Custom Node Position", 
-                                  "Drawing: Chess Masters"])
+                                  "Drawing: Chess Masters", "Drawing: Cluster Layout"])
 
 # Helper function to draw and display graph
 def draw_graph(G, pos=None, title="Graph Visualization", edgewidth=None, nodesize=None):
@@ -50,111 +49,60 @@ def draw_graph(G, pos=None, title="Graph Visualization", edgewidth=None, nodesiz
     plt.axis("off")
     st.pyplot(plt)
 
+# Drawing: Cluster Layout
+def display_cluster_layout():
+    st.title("Drawing: Cluster Layout")
 
-def chess_pgn_graph(pgn_file="chess_masters_WCC.pgn.bz2"):
-    """Read chess games in pgn format in pgn_file.
-    
-    Filenames ending in .bz2 will be uncompressed.
-    
-    Return the MultiDiGraph of players connected by a chess game.
-    Edges contain game data in a dict.
-    """
-    G = nx.MultiDiGraph()
-    game = {}
-    with bz2.BZ2File(pgn_file) as datafile:
-        lines = [line.decode().rstrip("\r\n") for line in datafile]
-    for line in lines:
-        if line.startswith("["):
-            tag, value = line[1:-1].split(" ", 1)
-            game[str(tag)] = value.strip('"')
-        else:
-            if game:
-                white = game.pop("White")
-                black = game.pop("Black")
-                G.add_edge(white, black, **game)
-                game = {}
-    return G
+    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
 
+    if option == "Default Example":
+        G = nx.davis_southern_women_graph()
 
-# Draw Chess Masters Graph (the main section)
-def display_chess_masters_graph():
-    st.title("Drawing: Chess Masters")
+        # Compute communities using greedy modularity community detection
+        communities = nx.community.greedy_modularity_communities(G)
 
-    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
+        # Compute positions for the node clusters as if they were themselves nodes in a supergraph
+        supergraph = nx.cycle_graph(len(communities))
+        superpos = nx.spring_layout(G, scale=50, seed=429)
 
-    if option == "Default Example":
-        G = chess_pgn_graph("chess_masters_WCC.pgn.bz2")
-
-        # identify connected components of the undirected version
-        H = G.to_undirected()
-        Gcc = [H.subgraph(c) for c in nx.connected_components(H)]
-        if len(Gcc) > 1:
-            st.write(f"Note the disconnected component consisting of:\n{Gcc[1].nodes()}")
-
-        # find all games with B97 opening (as described in ECO)
-        openings = {game_info["ECO"] for (white, black, game_info) in G.edges(data=True)}
-        st.write(f"\nFrom a total of {len(openings)} different openings,")
-        st.write("the following games used the Sicilian opening")
-        st.write('with the Najdorff 7...Qb6 "Poisoned Pawn" variation.\n')
-
-        for white, black, game_info in G.edges(data=True):
-            if game_info["ECO"] == "B97":
-                summary = f"{white} vs {black}\n"
-                for k, v in game_info.items():
-                    summary += f"   {k}: {v}\n"
-                summary += "\n"
-                st.write(summary)
-
-        # Create undirected graph H without multi-edges
-        H = nx.Graph(G)
-
-        # Edge width is proportional to number of games played
-        edgewidth = [len(G.get_edge_data(u, v)) for u, v in H.edges()]
-
-        # Node size is proportional to number of games won
-        wins = dict.fromkeys(G.nodes(), 0.0)
-        for u, v, d in G.edges(data=True):
-            r = d["Result"].split("-")
-            if r[0] == "1":
-                wins[u] += 1.0
-            elif r[0] == "1/2":
-                wins[u] += 0.5
-                wins[v] += 0.5
-            else:
-                wins[v] += 1.0
-        nodesize = [wins[v] * 50 for v in H]
-
-        # Generate layout for visualization
-        pos = nx.kamada_kawai_layout(H)
-
-        # Manually tweak some positions to avoid label overlap
-        pos["Reshevsky, Samuel H"] += (0.05, -0.10)
-        pos["Botvinnik, Mikhail M"] += (0.03, -0.06)
-        pos["Smyslov, Vassily V"] += (0.05, -0.03)
-
-        # Draw the graph
-        draw_graph(H, pos, title="World Chess Championship Games: 1886 - 1985", edgewidth=edgewidth, nodesize=nodesize)
+        # Use the "supernode" positions as the center of each node cluster
+        centers = list(superpos.values())
+        pos = {}
+        for center, comm in zip(centers, communities):
+            pos.update(nx.spring_layout(nx.subgraph(G, comm), center=center, seed=1430))
+
+        # Nodes colored by cluster
+        for nodes, clr in zip(communities, ("tab:blue", "tab:orange", "tab:green")):
+            nx.draw_networkx_nodes(G, pos=pos, nodelist=nodes, node_color=clr, node_size=100)
+        nx.draw_networkx_edges(G, pos=pos)
+
+        plt.tight_layout()
+        st.pyplot(plt)
 
     elif option == "Create your own":
-        uploaded_file = st.file_uploader("Upload your own PGN file", type="pgn")
+        uploaded_file = st.file_uploader("Upload your own graph file (in GML format)", type="gml")
         if uploaded_file is not None:
-            G_custom = chess_pgn_graph(uploaded_file)
-            # Identify connected components and draw the graph for the uploaded data
-            H_custom = G_custom.to_undirected()
-            edgewidth = [len(G_custom.get_edge_data(u, v)) for u, v in H_custom.edges()]
-            wins = dict.fromkeys(G_custom.nodes(), 0.0)
-            for u, v, d in G_custom.edges(data=True):
-                r = d["Result"].split("-")
-                if r[0] == "1":
-                    wins[u] += 1.0
-                elif r[0] == "1/2":
-                    wins[u] += 0.5
-                    wins[v] += 0.5
-                else:
-                    wins[v] += 1.0
-            nodesize = [wins[v] * 50 for v in H_custom]
-            pos_custom = nx.kamada_kawai_layout(H_custom)
-            draw_graph(H_custom, pos_custom, title="Custom Chess Game Graph", edgewidth=edgewidth, nodesize=nodesize)
+            G_custom = nx.read_gml(uploaded_file)
+            # Compute communities using greedy modularity community detection
+            communities = nx.community.greedy_modularity_communities(G_custom)
+
+            # Compute positions for the node clusters as if they were themselves nodes in a supergraph
+            supergraph = nx.cycle_graph(len(communities))
+            superpos = nx.spring_layout(G_custom, scale=50, seed=429)
+
+            # Use the "supernode" positions as the center of each node cluster
+            centers = list(superpos.values())
+            pos = {}
+            for center, comm in zip(centers, communities):
+                pos.update(nx.spring_layout(nx.subgraph(G_custom, comm), center=center, seed=1430))
+
+            # Nodes colored by cluster
+            for nodes, clr in zip(communities, ("tab:blue", "tab:orange", "tab:green")):
+                nx.draw_networkx_nodes(G_custom, pos=pos, nodelist=nodes, node_color=clr, node_size=100)
+            nx.draw_networkx_edges(G_custom, pos=pos)
+
+            plt.tight_layout()
+            st.pyplot(plt)
 
 # Display other sections
 def display_basic_properties():
@@ -260,5 +208,7 @@ elif sidebar_option == "Drawing: Custom Node Position":
     display_custom_node_position()
 elif sidebar_option == "Drawing: Chess Masters":
     display_chess_masters_graph()
+elif sidebar_option == "Drawing: Cluster Layout":
+    display_cluster_layout()
 else:
     st.write("Please select a valid option from the sidebar.")