app.y

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,18 +4,21 @@ 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
-from io import BytesIO
+
+# --- Topological Index Functions ---
 
 def wiener_index(graph):
     sp = dict(nx.all_pairs_shortest_path_length(graph))
@@ -56,22 +59,30 @@ def compute_indices(graph, index_type):
     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')
 
-    # Save directly to memory buffer, no disk usage!
-    buf = BytesIO()
-    plt.savefig(buf, format='png', bbox_inches='tight')
+    filename = "graph.png"
+    plt.savefig(filename, bbox_inches='tight')
     plt.close()
-    buf.seek(0)
-    return buf
+    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:
@@ -90,15 +101,17 @@ 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 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",
+        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"
     )
@@ -118,5 +131,7 @@ with gr.Blocks() as demo:
         outputs=[result_box, graph_output]
     )
 
+# --- Run the App ---
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()