Update app.py

app.py

@@ -1,21 +1,175 @@
 import streamlit as st
 import matplotlib.pyplot as plt
 import networkx as nx
+import bz2
 import numpy as np
 
 # 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"])
+                                  "Basic: Simple graph Directed", "Drawing: Custom Node Position", 
+                                  "Drawing: Chess Masters"])
 
 # Helper function to draw and display graph
 def draw_graph(G, pos=None, title="Graph Visualization"):
-    plt.figure(figsize=(8, 6))
-    nx.draw(G, pos=pos, with_labels=True, node_color='lightblue', node_size=500, font_size=10, font_weight='bold')
+    plt.figure(figsize=(12, 12))
+    nx.draw_networkx_edges(G, pos, alpha=0.3, width=edgewidth, edge_color="m")
+    nx.draw_networkx_nodes(G, pos, node_size=nodesize, node_color="#210070", alpha=0.9)
+    label_options = {"ec": "k", "fc": "white", "alpha": 0.7}
+    nx.draw_networkx_labels(G, pos, font_size=14, bbox=label_options)
+    
+    # Title/legend
+    font = {"fontname": "Helvetica", "color": "k", "fontweight": "bold", "fontsize": 14}
+    ax = plt.gca()
+    ax.set_title(title, font)
+    ax.text(
+        0.80,
+        0.10,
+        "edge width = # games played",
+        horizontalalignment="center",
+        transform=ax.transAxes,
+        fontdict=font,
+    )
+    ax.text(
+        0.80,
+        0.06,
+        "node size = # games won",
+        horizontalalignment="center",
+        transform=ax.transAxes,
+        fontdict=font,
+    )
+
+    # Resize figure for label readability
+    ax.margins(0.1, 0.05)
+    plt.axis("off")
     st.pyplot(plt)
 
-# Function to display properties and graph for Basic: Properties
+
+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
+
+
+# Draw Chess Masters Graph (the main section)
+def display_chess_masters_graph():
+    st.title("Drawing: Chess Masters")
+
+    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
+
+    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")
+
+    elif option == "Create your own":
+        uploaded_file = st.file_uploader("Upload your own PGN file", type="pgn")
+        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")
+
+# Display other sections
+def display_basic_properties():
+    st.title("Basic: Properties")
+    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
+
+    # Default example: 5x5 grid graph
+    if option == "Default Example":
+        G = nx.lollipop_graph(4, 6)
+        display_graph_properties(G)
+
+    elif option == "Create your own":
+        num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=50, value=5)
+        num_edges = st.number_input("Number of edges per group (for lollipop graph):", min_value=1, max_value=10, value=3)
+
+        if st.button("Generate"):
+            if num_nodes >= 2 and num_edges >= 1:
+                G_custom = nx.lollipop_graph(num_nodes, num_edges)
+                display_graph_properties(G_custom)
+
 def display_graph_properties(G):
     pathlengths = []
     st.write("### Source vertex {target:length, }")
@@ -30,7 +184,11 @@ def display_graph_properties(G):
 
     dist = {}
     for p in pathlengths:
-        dist[p] = dist.get(p, 0) + 1
+        if p in dist:
+            dist[p] += 1
+        else:
+            dist[p] = 1
+
     st.write("### Length #paths")
     for d in sorted(dist.keys()):
         st.write(f"Length {d}: {dist[d]} paths")
@@ -43,188 +201,59 @@ def display_graph_properties(G):
     st.write(f"Periphery: {nx.periphery(G)}")
     st.write(f"Density: {nx.density(G)}")
 
-    # Visualize the graph
     st.write("### Graph Visualization")
-    pos = nx.spring_layout(G, seed=3068)  # Seed layout for reproducibility
-    draw_graph(G, pos)
-
-# Function to display graph for Basic: Read and write graphs
-def display_read_write_graph(G):
-    st.write("### Adjacency List:")
-    for line in nx.generate_adjlist(G):
-        st.write(line)
-    
-    # Write the graph's edge list to a file
-    st.write("### Writing Edge List to 'grid.edgelist' file:")
-    nx.write_edgelist(G, path="grid.edgelist", delimiter=":")
-    st.write("Edge list written to 'grid.edgelist'")
-
-    # Read the graph from the edge list
-    st.write("### Reading Edge List from 'grid.edgelist' file:")
-    H = nx.read_edgelist(path="grid.edgelist", delimiter=":")
-    st.write("Edge list read into graph H")
-
-    # Visualize the graph
-    st.write("### Graph Visualization:")
-    pos = nx.spring_layout(H, seed=200)  # Seed for reproducibility
-    draw_graph(H, pos)
-
-# Function to display Simple Graphs for Basic: Simple graph
-def display_simple_graph(G, pos=None):
-    options = {
-        "font_size": 36,
-        "node_size": 3000,
-        "node_color": "white",
-        "edgecolors": "black",
-        "linewidths": 5,
-        "width": 5,
-    }
-    
-    # Draw the network
-    nx.draw_networkx(G, pos, **options)
+    pos = nx.spring_layout(G, seed=3068)
+    plt.figure(figsize=(8, 6))
+    nx.draw(G, pos=pos, with_labels=True, node_color='lightblue', node_size=500, font_size=10, font_weight='bold')
+    st.pyplot(plt)
 
-    # Set margins for the axes so that nodes aren't clipped
-    ax = plt.gca()
-    ax.margins(0.20)
-    plt.axis("off")
+# Display other sections
+def display_read_write_graph():
+    st.title("Basic: Read and write graphs")
+    G = nx.karate_club_graph()
+
+    # Write the graph
+    nx.write_gml(G, "karate_club.gml")
+    st.write("Graph written to 'karate_club.gml'.")
+
+    # Read the graph back
+    G_new = nx.read_gml("karate_club.gml")
+    st.write("Graph read back from 'karate_club.gml'.")
+    nx.draw(G_new, with_labels=True)
     st.pyplot(plt)
 
-# Function to display Simple Directed Graphs for Basic: Simple graph Directed
-def display_simple_directed_graph(G, pos=None):
-    options = {
-        "node_size": 500,
-        "node_color": "lightblue",
-        "arrowsize": 20,
-        "width": 2,
-        "edge_color": "gray",
-    }
-    
-    # Draw the directed graph with the given positions and options
-    nx.draw_networkx(G, pos, **options)
+def display_simple_graph():
+    st.title("Basic: Simple graph")
+    G = nx.complete_graph(5)
+    nx.draw(G, with_labels=True)
+    st.pyplot(plt)
 
-    # Set margins for the axes so that nodes aren't clipped
-    ax = plt.gca()
-    ax.margins(0.20)
-    plt.axis("off")
+def display_simple_directed_graph():
+    st.title("Basic: Simple graph Directed")
+    G = nx.complete_graph(5, nx.DiGraph())
+    nx.draw(G, with_labels=True)
     st.pyplot(plt)
 
-# Function to display Custom Node Position Graphs for Drawing: Custom Node Position
 def display_custom_node_position():
     st.title("Drawing: Custom Node Position")
-    
-    # Default example graph (path graph with custom node position)
-    G = nx.path_graph(20)
-    center_node = 5
-    edge_nodes = set(G) - {center_node}
-    
-    # Ensure the nodes around the circle are evenly distributed
-    pos = nx.circular_layout(G.subgraph(edge_nodes))
-    pos[center_node] = np.array([0, 0])  # Manually specify node position
-    
-    # Draw the graph
-    draw_graph(G, pos)
-
-# Display Basic: Properties if selected
-if sidebar_option == "Basic: Properties":
-    st.title("Basic: Properties")
-    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
-
-    if option == "Default Example":
-        G = nx.lollipop_graph(4, 6)
-        display_graph_properties(G)
+    pos = {"A": (1, 2), "B": (2, 3), "C": (3, 1)}
+    G = nx.Graph(pos)
+    nx.draw(G, pos=pos, with_labels=True)
+    st.pyplot(plt)
 
-    elif option == "Create your own":
-        num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=50, value=5)
-        num_edges = st.number_input("Number of edges per group (for lollipop graph):", min_value=1, max_value=10, value=3)
 
-        if st.button("Generate"):
-            if num_nodes >= 2 and num_edges >= 1:
-                G_custom = nx.lollipop_graph(num_nodes, num_edges)
-                display_graph_properties(G_custom)
-
-# Display Basic: Read and write graphs if selected
+# Call the appropriate function based on sidebar selection
+if sidebar_option == "Basic: Properties":
+    display_basic_properties()
 elif sidebar_option == "Basic: Read and write graphs":
-    st.title("Basic: Read and write graphs")
-    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
-
-    if option == "Default Example":
-        G = nx.grid_2d_graph(5, 5)
-        display_read_write_graph(G)
-
-    elif option == "Create your own":
-        rows = st.number_input("Number of rows:", min_value=2, max_value=20, value=5)
-        cols = st.number_input("Number of columns:", min_value=2, max_value=20, value=5)
-
-        if st.button("Generate"):
-            if rows >= 2 and cols >= 2:
-                G_custom = nx.grid_2d_graph(rows, cols)
-                display_read_write_graph(G_custom)
-
-# Display Basic: Simple Graph if selected
+    display_read_write_graph()
 elif sidebar_option == "Basic: Simple graph":
-    st.title("Basic: Simple graph")
-    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
-
-    if option == "Default Example":
-        G = nx.Graph()
-        G.add_edge(1, 2)
-        G.add_edge(1, 3)
-        G.add_edge(1, 5)
-        G.add_edge(2, 3)
-        G.add_edge(3, 4)
-        G.add_edge(4, 5)
-
-        pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}
-        display_simple_graph(G, pos)
-
-    elif option == "Create your own":
-        edges = []
-        edge_input = st.text_area("Edges:", value="1,2\n1,3\n2,3")
-        if edge_input:
-            edge_list = edge_input.split("\n")
-            for edge in edge_list:
-                u, v = map(int, edge.split(","))
-                edges.append((u, v))
-
-        if st.button("Generate"):
-            G_custom = nx.Graph()
-            G_custom.add_edges_from(edges)
-            pos = nx.spring_layout(G_custom, seed=42)
-            display_simple_graph(G_custom, pos)
-
-# Display Basic: Simple Directed Graph if selected
+    display_simple_graph()
 elif sidebar_option == "Basic: Simple graph Directed":
-    st.title("Basic: Simple graph Directed")
-    option = st.radio("Choose a graph type:", ("Default Example", "Create your own"))
-
-    if option == "Default Example":
-        G = nx.DiGraph([(0, 3), (1, 3), (2, 4), (3, 5), (3, 6), (4, 6), (5, 6)])
-
-        left_nodes = [0, 1, 2]
-        middle_nodes = [3, 4]
-        right_nodes = [5, 6]
-
-        pos = {n: (0, i) for i, n in enumerate(left_nodes)}
-        pos.update({n: (1, i + 0.5) for i, n in enumerate(middle_nodes)})
-        pos.update({n: (2, i + 0.5) for i, n in enumerate(right_nodes)})
-
-        display_simple_directed_graph(G, pos)
-
-    elif option == "Create your own":
-        edges = []
-        edge_input = st.text_area("Edges:", value="1,2\n1,3\n2,3")
-        if edge_input:
-            edge_list = edge_input.split("\n")
-            for edge in edge_list:
-                u, v = map(int, edge.split(","))
-                edges.append((u, v))
-
-        if st.button("Generate"):
-            G_custom = nx.DiGraph()
-            G_custom.add_edges_from(edges)
-            pos = nx.spring_layout(G_custom, seed=42)
-            display_simple_directed_graph(G_custom, pos)
-
-# Display Drawing: Custom Node Position if selected
+    display_simple_directed_graph()
 elif sidebar_option == "Drawing: Custom Node Position":
     display_custom_node_position()
+elif sidebar_option == "Drawing: Chess Masters":
+    display_chess_masters_graph()
+else:
+    st.write("Please select a valid option from the sidebar.")