Update app.py

app.py

@@ -23,114 +23,7 @@ sidebar_option = st.sidebar.radio("Select an option",
                                   "Drawing: Simple Path", "Drawing: Spectral Embedding", "Drawing: Traveling Salesman Problem",
                                   "Drawing: Weighted Graph", "3D Drawing: Animations of 3D Rotation", "3D Drawing: Basic Matplotlib",
                                   "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, 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 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)}
-        )
-        plt.title(f"Shortest Path from {start} to {end}")
-        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")
-
-    # Option to choose between creating your own or using the default example
-    graph_mode = st.radio(
-        "Choose a Mode:",
-        ("Default Example", "Create Your Own"),
-        help="The default example shows a predefined graph, or you can create your own."
-    )
-
-    if graph_mode == "Default Example":
-        # 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)
-        G.add_edge("A", "H", weight=8)
-        G.add_edge("B", "C", weight=8)
-        G.add_edge("B", "H", weight=11)
-        G.add_edge("C", "D", weight=7)
-        G.add_edge("C", "F", weight=4)
-        G.add_edge("C", "I", weight=2)
-        G.add_edge("D", "E", weight=9)
-        G.add_edge("D", "F", weight=14)
-        G.add_edge("E", "F", weight=10)
-        G.add_edge("F", "G", weight=2)
-        G.add_edge("G", "H", weight=1)
-        G.add_edge("G", "I", weight=6)
-        G.add_edge("H", "I", weight=7)
-
-        # 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 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):")
-
-        if st.button("Generate Graph"):
-            if nodes_input and edges_input and start_node and end_node:
-                try:
-                    # Parse the input for nodes and edges
-                    nodes = nodes_input.split(",")
-                    edges = [
-                        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 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())
-
-                    # 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}")
-            else:
-                st.error("Please enter valid nodes, edges, and start/end nodes.")
-
-if sidebar_option == "Algorithms: Find Shortest Path":
-    algorithms_shortest_path()
+                                  "Graph: Triads", "Algorithms: Cycle Detection", "Algorithms: Greedy Coloring"])
 
 def plot_greedy_coloring(graph):
     # Apply greedy coloring