Update app.py

app.py

@@ -25,31 +25,36 @@ sidebar_option = st.sidebar.radio("Select an option",
                                   "Graph: DAG - Topological Layout", "Graph: Erdos Renyi", "Graph: Karate Club", "Graph: Minimum Spanning Tree",
                                   "Graph: Triads", "Algorithms: Cycle Detection", "Algorithms: Greedy Coloring", "Algorithms: Find Shortest Path"])
 
-def plot_shortest_path(graph, start_node, end_node):
-    # Find the shortest path from start_node to end_node
-    path = nx.shortest_path(graph, start_node, end_node, weight="weight")
-    st.write("Shortest Path:", path)
+def plot_shortest_path(graph, start, end):
+    try:
+        # Find the shortest path from start to end node
+        path = nx.shortest_path(graph, source=start, target=end, weight='weight')
+        st.write(f"Shortest path from {start} to {end}:", path)
 
-    # Create a list of edges in the shortest path
-    path_edges = list(zip(path, path[1:]))
+        # Create a list of edges in the shortest path
+        path_edges = list(zip(path, path[1:]))
 
-    # Create a list of all edges, and assign colors based on whether they are in the shortest path or not
-    edge_colors = [
-        "red" if edge in path_edges or tuple(reversed(edge)) in path_edges else "black"
-        for edge in graph.edges()
-    ]
+        # Create a list of all edges, and assign colors based on whether they are in the shortest path or not
+        edge_colors = [
+            "red" if edge in path_edges or tuple(reversed(edge)) in path_edges else "black"
+            for edge in graph.edges()
+        ]
 
-    # Visualize the graph
-    pos = nx.spring_layout(graph)
-    nx.draw_networkx_nodes(graph, pos)
-    nx.draw_networkx_edges(graph, pos, edge_color=edge_colors)
-    nx.draw_networkx_labels(graph, pos)
-    nx.draw_networkx_edge_labels(
-        graph, pos, edge_labels={(u, v): d["weight"] for u, v, d in graph.edges(data=True)}
-    )
+        # Visualize the graph
+        pos = nx.spring_layout(graph)
+        nx.draw_networkx_nodes(graph, pos)
+        nx.draw_networkx_edges(graph, pos, edge_color=edge_colors)
+        nx.draw_networkx_labels(graph, pos)
+        nx.draw_networkx_edge_labels(
+            graph, pos, edge_labels={(u, v): d["weight"] for u, v, d in graph.edges(data=True)}
+        )
+        plt.title(f"Shortest Path from {start} to {end}")
+        st.pyplot(plt)
 
-    plt.title(f"Shortest Path from {start_node} to {end_node}")
-    st.pyplot(plt)
+    except nx.NetworkXNoPath:
+        st.error(f"No path found between {start} and {end}.")
+    except nx.NodeNotFound as e:
+        st.error(f"Error: {str(e)}")
 
 def algorithms_shortest_path():
     st.title("Algorithms: Find Shortest Path")
@@ -62,7 +67,7 @@ def algorithms_shortest_path():
     )
 
     if graph_mode == "Default Example":
-        # Create a predefined graph with nodes and weighted edges
+        # Create a predefined graph for the shortest path example
         G = nx.Graph()
         G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
         G.add_edge("A", "B", weight=4)
@@ -80,20 +85,17 @@ def algorithms_shortest_path():
         G.add_edge("G", "I", weight=6)
         G.add_edge("H", "I", weight=7)
 
-        # Set default start and end nodes
-        start_node = "A"
-        end_node = "E"
-        st.write(f"Finding the shortest path from {start_node} to {end_node}")
-        plot_shortest_path(G, start_node, end_node)
+        # Set start and end nodes
+        start = "A"
+        end = "E"
+        plot_shortest_path(G, start, end)
 
     elif graph_mode == "Create Your Own":
         st.write("### Create Your Own Graph")
 
-        # Input for nodes
-        nodes_input = st.text_area("Enter nodes (e.g., A, B, C, D, E, F, G, H):")
-        edges_input = st.text_area("Enter edges with weights (e.g., (A, B, 4), (B, C, 8)):").strip()
-
-        # Input for start and end nodes
+        # Input for creating a custom graph
+        nodes_input = st.text_area("Enter nodes (e.g., A, B, C, D):")
+        edges_input = st.text_area("Enter edges with weights (e.g., A,B,4, B,C,7):").strip()
         start_node = st.text_input("Enter start node (e.g., A):")
         end_node = st.text_input("Enter end node (e.g., E):")
 
@@ -103,20 +105,24 @@ def algorithms_shortest_path():
                     # Parse the input for nodes and edges
                     nodes = nodes_input.split(",")
                     edges = [
-                        tuple(edge.strip()[1:-1].split(",") + [edge.strip().split(",")[-1]])
-                        for edge in edges_input.split("),")
-                    ]
-                    edges = [
-                        (edge[0], edge[1], int(edge[2])) for edge in edges if len(edge) == 3
+                        tuple(edge.split(","))
+                        for edge in edges_input.split("\n") if edge.strip()
                     ]
+                    edges = [(u, v, int(weight)) for u, v, weight in edges]  # Parse weights as integers
 
-                    # Create the graph and add nodes and edges
+                    # Create graph
                     G = nx.Graph()
                     G.add_nodes_from(nodes)
                     G.add_weighted_edges_from(edges)
 
+                    # Show custom graph edges
                     st.write("Custom Graph:", G.edges())
-                    plot_shortest_path(G, start_node, end_node)
+
+                    # Check if start and end nodes are valid
+                    if start_node not in G.nodes or end_node not in G.nodes:
+                        st.error("Start or End node is not in the graph!")
+                    else:
+                        plot_shortest_path(G, start_node, end_node)
 
                 except Exception as e:
                     st.error(f"Error creating the graph: {e}")