app.py

import os
import subprocess

def install(package):
subprocess.check_call(["pip", "install", package])

# Install dependencies
install("numpy")
install("networkx")
install("matplotlib")
install("gradio")

# Now import the installed libraries
import math
import itertools
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
import gradio as gr

# --- Topological Index Functions ---

def wiener_index(graph):
sp = dict(nx.all_pairs_shortest_path_length(graph))
total = 0
for u in sp:
for v in sp[u]:
if u < v:
total += sp[u][v]
return total

def compute_indices(graph, index_type):
if index_type == "Wiener Index":
return wiener_index(graph)
elif index_type == "Randić Index":
return sum(1 / math.sqrt(graph.degree(u) * graph.degree(v)) for u, v in graph.edges())
elif index_type == "Balaban Index":
n = graph.number_of_nodes()
m = graph.number_of_edges()
if m == 0 or n <= 1:
return 0
return (m / (n - 1)) * sum(1 / math.sqrt(graph.degree(u) * graph.degree(v)) for u, v in graph.edges())
elif index_type == "Zagreb Index M1":
return sum(d**2 for _, d in graph.degree())
elif index_type == "Zagreb Index M2":
return sum(graph.degree(u) * graph.degree(v) for u, v in graph.edges())
elif index_type == "Harary Index":
return sum(1 / nx.shortest_path_length(graph, u, v) for u, v in itertools.combinations(graph.nodes(), 2))
elif index_type == "Schultz Index":
return sum((graph.degree(u) + graph.degree(v)) * nx.shortest_path_length(graph, u, v) for u, v in graph.edges())
elif index_type == "Gutman Index":
return sum(graph.degree(u) * graph.degree(v) * nx.shortest_path_length(graph, u, v) for u, v in graph.edges())
elif index_type == "Estrada Index":
A = nx.adjacency_matrix(graph).todense()
eigenvalues = np.linalg.eigvals(A)
return sum(math.exp(ev) for ev in eigenvalues)
elif index_type == "Hosoya Index":
return graph.number_of_edges()
else:
return "Invalid Index Type"

# --- Graph Drawing Function ---

def draw_graph(graph, index_type, index_value):
plt.figure(figsize=(6, 6))

# Fixed layout for more consistent shapes
pos = nx.spring_layout(graph, seed=42)

# Draw only edges (no nodes, no labels)
nx.draw_networkx_edges(graph, pos, edge_color="gray", width=2)

plt.title(f"{index_type}: {round(index_value, 3)}", fontsize=14)
plt.axis('off')

filename = "graph.png"
plt.savefig(filename, bbox_inches='tight')
plt.close()
return filename

# --- Main Logic ---

def process_graph(node_count, edge_count, index_type, custom_edges):
G = nx.Graph()

if not custom_edges.strip():
G = nx.gnm_random_graph(int(node_count), int(edge_count))
else:
try:
edges = [tuple(map(int, e.strip().split("-"))) for e in custom_edges.split(",")]
all_nodes = set()
for u, v in edges:
all_nodes.update([u, v])
n = max(all_nodes) + 1
G.add_nodes_from(range(n))
G.add_edges_from(edges)
except Exception as e:
return f"Error in custom edges input: {e}", None

index_value = compute_indices(G, index_type)
graph_img = draw_graph(G, index_type, index_value)
return index_value, graph_img

# --- Gradio App ---

with gr.Blocks() as demo:
gr.Markdown("# 🧠 Topological Index Calculator with Graph Visualization")

with gr.Row():
node_count = gr.Number(label="Number of Nodes", value=5, minimum=1)
edge_count = gr.Number(label="Number of Edges", value=5, minimum=0)

index_type = gr.Dropdown(
choices=["Wiener Index", "Randić Index", "Balaban Index", "Zagreb Index M1", "Zagreb Index M2",
"Harary Index", "Schultz Index", "Gutman Index", "Estrada Index", "Hosoya Index"],
label="Select Topological Index"
)

custom_edges = gr.Textbox(
label="Custom Edges (e.g., 0-1,1-2,2-3)",
placeholder="Leave blank for random graph"
)

calc_button = gr.Button("Calculate & Visualize")
result_box = gr.Textbox(label="Computed Index Value", interactive=False)
graph_output = gr.Image(label="Graph Visualization", interactive=False)

calc_button.click(
fn=process_graph,
inputs=[node_count, edge_count, index_type, custom_edges],
outputs=[result_box, graph_output]
)

# --- Run the App ---

if __name__ == "__main__":
demo.launch()

app.py

@@ -4,7 +4,7 @@ import subprocess
 def install(package):
     subprocess.check_call(["pip", "install", package])
 
-# Manually install each required library
+# Install dependencies
 install("numpy")
 install("networkx")
 install("matplotlib")
@@ -21,9 +21,6 @@ import gradio as gr
 # --- Topological Index Functions ---
 
 def wiener_index(graph):
-    """
-    Wiener Index: Sum of shortest path distances between all pairs of vertices.
-    """
     sp = dict(nx.all_pairs_shortest_path_length(graph))
     total = 0
     for u in sp:
@@ -35,86 +32,57 @@ def wiener_index(graph):
 def compute_indices(graph, index_type):
     if index_type == "Wiener Index":
         return wiener_index(graph)
-    
     elif index_type == "Randić Index":
-        # Randić Index = Σ[1/√(d(u)*d(v))] for every edge (u,v)
         return sum(1 / math.sqrt(graph.degree(u) * graph.degree(v)) for u, v in graph.edges())
-    
     elif index_type == "Balaban Index":
         n = graph.number_of_nodes()
         m = graph.number_of_edges()
         if m == 0 or n <= 1:
             return 0
         return (m / (n - 1)) * sum(1 / math.sqrt(graph.degree(u) * graph.degree(v)) for u, v in graph.edges())
-    
     elif index_type == "Zagreb Index M1":
-        # M1 = Σ[d(v)]² over all vertices
         return sum(d**2 for _, d in graph.degree())
-    
     elif index_type == "Zagreb Index M2":
-        # M2 = Σ[d(u)*d(v)] for every edge (u,v)
         return sum(graph.degree(u) * graph.degree(v) for u, v in graph.edges())
-    
     elif index_type == "Harary Index":
-        # H = Σ[1 / d(u,v)] for all distinct vertex pairs
-        return sum(1 / nx.shortest_path_length(graph, u, v) 
-                   for u, v in itertools.combinations(graph.nodes(), 2))
-    
+        return sum(1 / nx.shortest_path_length(graph, u, v) for u, v in itertools.combinations(graph.nodes(), 2))
     elif index_type == "Schultz Index":
-        # Schultz Index = Σ[(d(u)+d(v))*d(u,v)] over all edges (as a simplified version)
-        return sum((graph.degree(u) + graph.degree(v)) * nx.shortest_path_length(graph, u, v)
-                   for u, v in graph.edges())
-    
+        return sum((graph.degree(u) + graph.degree(v)) * nx.shortest_path_length(graph, u, v) for u, v in graph.edges())
     elif index_type == "Gutman Index":
-        # Gutman Index = Σ[d(u)*d(v)*d(u,v)] over all edges
-        return sum(graph.degree(u) * graph.degree(v) * nx.shortest_path_length(graph, u, v)
-                   for u, v in graph.edges())
-    
+        return sum(graph.degree(u) * graph.degree(v) * nx.shortest_path_length(graph, u, v) for u, v in graph.edges())
     elif index_type == "Estrada Index":
-        # Estrada Index = Σ(exp(λ)) over all eigenvalues of the adjacency matrix.
         A = nx.adjacency_matrix(graph).todense()
         eigenvalues = np.linalg.eigvals(A)
         return sum(math.exp(ev) for ev in eigenvalues)
-    
     elif index_type == "Hosoya Index":
-        # Hosoya Index counts the number of matchings in a graph.
-        # For simplicity, we use a dummy value: the number of edges.
         return graph.number_of_edges()
-    
     else:
         return "Invalid Index Type"
 
-# --- Graph Visualization Function ---
+# --- Graph Drawing Function ---
 
 def draw_graph(graph, index_type, index_value):
-    """
-    Draws the graph using a spring layout.
-    Only the edges are drawn (removing the blue nodes with numbers).
-    The title shows the index type and computed value.
-    """
     plt.figure(figsize=(6, 6))
-    pos = nx.spring_layout(graph, seed=42)
-    
-    # Draw only the edges
-    nx.draw_networkx_edges(graph, pos, edge_color="gray")
     
+    # Fixed layout for more consistent shapes
+    pos = nx.spring_layout(graph, seed=42)
+
+    # Draw only edges (no nodes, no labels)
+    nx.draw_networkx_edges(graph, pos, edge_color="gray", width=2)
+
     plt.title(f"{index_type}: {round(index_value, 3)}", fontsize=14)
-    
-    # Save the plot as an image and return its filename.
+    plt.axis('off')
+
     filename = "graph.png"
-    plt.savefig(filename)
+    plt.savefig(filename, bbox_inches='tight')
     plt.close()
     return filename
 
-# --- Main Processing Function ---
+# --- Main Logic ---
 
 def process_graph(node_count, edge_count, index_type, custom_edges):
-    """
-    Creates a graph either from random generation or from custom edge input.
-    Then computes the selected topological index and draws the graph.
-    """
     G = nx.Graph()
-    # If custom_edges is empty, generate a random graph with given node and edge counts.
+    
     if not custom_edges.strip():
         G = nx.gnm_random_graph(int(node_count), int(edge_count))
     else:
@@ -124,7 +92,6 @@ def process_graph(node_count, edge_count, index_type, custom_edges):
             for u, v in edges:
                 all_nodes.update([u, v])
             n = max(all_nodes) + 1
-            G = nx.Graph()
             G.add_nodes_from(range(n))
             G.add_edges_from(edges)
         except Exception as e:
@@ -134,27 +101,30 @@ def process_graph(node_count, edge_count, index_type, custom_edges):
     graph_img = draw_graph(G, index_type, index_value)
     return index_value, graph_img
 
-# --- Gradio Interface Setup ---
+# --- Gradio App ---
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Topological Index Calculator with Graph Visualization")
+    gr.Markdown("# 🧠 Topological Index Calculator with Graph Visualization")
     
     with gr.Row():
         node_count = gr.Number(label="Number of Nodes", value=5, minimum=1)
         edge_count = gr.Number(label="Number of Edges", value=5, minimum=0)
-    
+
     index_type = gr.Dropdown(
         choices=["Wiener Index", "Randić Index", "Balaban Index", "Zagreb Index M1", "Zagreb Index M2", 
                  "Harary Index", "Schultz Index", "Gutman Index", "Estrada Index", "Hosoya Index"],
         label="Select Topological Index"
     )
-    
-    custom_edges = gr.Textbox(label="Custom Edges (e.g., 0-1,1-2,2-3)", placeholder="Leave blank for random graph")
-    
+
+    custom_edges = gr.Textbox(
+        label="Custom Edges (e.g., 0-1,1-2,2-3)", 
+        placeholder="Leave blank for random graph"
+    )
+
     calc_button = gr.Button("Calculate & Visualize")
     result_box = gr.Textbox(label="Computed Index Value", interactive=False)
     graph_output = gr.Image(label="Graph Visualization", interactive=False)
-    
+
     calc_button.click(
         fn=process_graph,
         inputs=[node_count, edge_count, index_type, custom_edges],
@@ -164,4 +134,4 @@ with gr.Blocks() as demo:
 # --- Run the App ---
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()