Update app.py

app.py

@@ -140,12 +140,9 @@ class NetworkGenerator:
         self.active_positions = None 
 
     def calculate_defaults(self):
-        """Helper to return what the defaults WOULD be for this config."""
-        # Nodes
         total_possible = (self.width + 1) * (self.height + 1)
         scale = {"highly_connected": 1.2, "bottlenecks": 0.85, "linear": 0.75}.get(self.topology, 1.0)
         
-        # Effective void fraction logic
         if self.topology == "highly_connected": vf = max(0.0, self.node_drop_fraction * 0.8)
         elif self.topology == "linear": vf = min(0.95, self.node_drop_fraction * 1.2)
         else: vf = self.node_drop_fraction
@@ -153,11 +150,9 @@ class NetworkGenerator:
         active_pct = 1.0 - vf
         est_nodes = int(self.node_factor * scale * total_possible * active_pct)
         
-        # Edges
         if self.topology == "highly_connected": est_edges = int(3.5 * est_nodes)
         elif self.topology == "bottlenecks": est_edges = int(1.8 * est_nodes)
         else: est_edges = int(1.5 * est_nodes)
-        
         return est_nodes, est_edges
 
     def generate(self):
@@ -224,21 +219,13 @@ class NetworkGenerator:
         self.graph.add_node(tuple(seed))
 
     def _add_nodes(self):
-        # Improved: Even with target count, try to respect topology distribution
         if self.target_nodes > 0:
             needed = self.target_nodes - len(self.graph.nodes())
             if needed <= 0: return
-            
             available = list(self.active_positions - set(self.graph.nodes()))
-            
-            # If bottleneck/highly connected, prefer clustering vs random scatter
             if self.topology != "linear" and len(available) > needed:
-                # Pick a random center and grow out
                 center = random.choice(list(self.graph.nodes()))
                 available.sort(key=lambda n: (n[0]-center[0])**2 + (n[1]-center[1])**2)
-                
-                # Take closest needed? No, that makes one big blob.
-                # Take random subset of available to avoid lines?
                 chosen = random.sample(available, needed)
                 for n in chosen: self.graph.add_node(n)
             else:
@@ -401,40 +388,29 @@ class NetworkGenerator:
                 if not self.graph.has_edge(*e1) or not self.graph.has_edge(*e2): continue
                 l1 = (e1[0][0]-e1[1][0])**2 + (e1[0][1]-e1[1][1])**2
                 l2 = (e2[0][0]-e2[1][0])**2 + (e2[0][1]-e2[1][1])**2
-                # FIX: remove_edge takes u,v. If rem is tuple, use *rem
                 rem = e1 if l1 > l2 else e2
                 self.graph.remove_edge(*rem)
 
     def _adjust_edges_to_target(self):
         current_edges = list(self.graph.edges())
         curr_count = len(current_edges)
-        
         if curr_count > self.target_edges:
             to_remove = curr_count - self.target_edges
-            # Remove edges that are longest first, but preserve "cluster" integrity if possible
             sorted_edges = sorted(current_edges, key=lambda e: (e[0][0]-e[1][0])**2 + (e[0][1]-e[1][1])**2, reverse=True)
             for e in sorted_edges:
                 if len(self.graph.edges()) <= self.target_edges: break
                 self.graph.remove_edge(*e)
                 if not nx.is_connected(self.graph): self.graph.add_edge(*e) 
-        
         elif curr_count < self.target_edges:
             needed = self.target_edges - curr_count
             nodes = list(self.graph.nodes())
             attempts = 0
-            
-            # IMPROVED STRATEGY FOR ADDING EDGES TO TARGET
-            # Instead of random (u,v), preferentially pick u,v that are close 
-            # or in same cluster to avoid "linear" lines across map
             while len(self.graph.edges()) < self.target_edges and attempts < (needed * 30):
                 attempts += 1
                 u = random.choice(nodes)
-                # Pick v close to u
                 candidates = sorted(nodes, key=lambda n: (n[0]-u[0])**2 + (n[1]-u[1])**2)
-                # Skip self, pick from nearest 10
                 if len(candidates) < 2: continue
                 v = random.choice(candidates[1:min(len(candidates), 10)])
-                
                 if not self.graph.has_edge(u, v) and not self._would_create_intersection(u, v):
                     self.graph.add_edge(u, v)
 
@@ -461,6 +437,9 @@ class NetworkGenerator:
 
     # === MANUAL EDITING ===
     def manual_add_node(self, x, y):
+        # FIX: Force Int Cast to avoid "Already Exists" due to float mismatch
+        x, y = int(x), int(y)
+        
         if not (0 <= x <= self.width and 0 <= y <= self.height): return False, "Out of bounds."
         if self.graph.has_node((x, y)): return False, "Already exists."
         self.graph.add_node((x, y))
@@ -487,14 +466,26 @@ class NetworkGenerator:
 # ==========================================
 # GRADIO HELPERS
 # ==========================================
-def plot_graph(graph, width, height, title="Network"):
+def plot_graph(graph, width, height, title="Network", highlight_node=None):
     fig, ax = plt.subplots(figsize=(8, 8))
     pos = {node: (node[0], node[1]) for node in graph.nodes()}
+    
+    # 1. Edges
     nx.draw_networkx_edges(graph, pos, ax=ax, width=2, alpha=0.6, edge_color="#333")
-    nx.draw_networkx_nodes(graph, pos, ax=ax, node_size=350, node_color="#4F46E5", edgecolors="white", linewidths=1.5)
+    
+    # 2. Nodes (Standard)
+    # Filter nodes that are NOT highlighted
+    normal_nodes = [n for n in graph.nodes() if n != highlight_node]
+    nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=normal_nodes, node_size=350, node_color="#4F46E5", edgecolors="white", linewidths=1.5)
+    
+    # 3. Nodes (Highlight)
+    if highlight_node and graph.has_node(highlight_node):
+        nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=[highlight_node], node_size=400, node_color="#EF4444", edgecolors="white", linewidths=2.0)
+    
     sorted_nodes = get_sorted_nodes(graph)
     labels = {node: str(i+1) for i, node in enumerate(sorted_nodes)}
     nx.draw_networkx_labels(graph, pos, labels, ax=ax, font_size=8, font_color="white", font_weight="bold")
+    
     ax.set_xlim(-1, width + 1)
     ax.set_ylim(-1, height + 1)
     ax.invert_yaxis() 
@@ -513,26 +504,19 @@ def get_preset_dims(preset_mode, topology):
     return gr.update(value=dims[0], interactive=False), gr.update(value=dims[1], interactive=False)
 
 def update_ui_for_variant(variant, width, height, topology, void_frac):
-    """Handles unlocking UI and Pre-filling Defaults."""
     is_custom = (variant == "Custom")
-    
     if is_custom:
-        # Calculate what the defaults WOULD be for this config
-        # so user starts editing from a reasonable number, not 0
         temp_gen = NetworkGenerator(width, height, "F", topology, void_frac)
         def_nodes, def_edges = temp_gen.calculate_defaults()
-        
         void_update = gr.update(interactive=True)
         target_node_update = gr.update(value=def_nodes, interactive=True)
         target_edge_update = gr.update(value=def_edges, interactive=True)
     else:
-        # Fixed Mode
         area = width * height
         val = 0.60 if area <= 20 else 0.35
         void_update = gr.update(value=val, interactive=False)
         target_node_update = gr.update(value=0, interactive=False)
         target_edge_update = gr.update(value=0, interactive=False)
-        
     return void_update, target_node_update, target_edge_update
 
 def save_single_visual_action(state_data):
@@ -564,12 +548,20 @@ def manual_edit_action(action, x, y, node_id, state_data):
     if not state_data or "graph" not in state_data: return None, "No graph.", state_data
     gen = NetworkGenerator(state_data["width"], state_data["height"]) 
     gen.graph = state_data["graph"] 
+    
+    # Store added node to pass to plotter
+    highlight = None
+    
     if action == "Add Node":
-        success, msg = gen.manual_add_node(int(x), int(y))
+        # Ensure Int here too
+        x, y = int(x), int(y)
+        success, msg = gen.manual_add_node(x, y)
+        if success: highlight = (x, y)
     else:
         success, msg = gen.manual_delete_node_by_id(node_id)
+        
     if success:
-        fig = plot_graph(gen.graph, state_data["width"], state_data["height"], "Edited")
+        fig = plot_graph(gen.graph, state_data["width"], state_data["height"], "Edited", highlight_node=highlight)
         metrics = f"**Nodes:** {len(gen.graph.nodes())} | **Edges:** {len(gen.graph.edges())} | {msg}"
         state_data["graph"] = gen.graph 
         return fig, metrics, state_data
@@ -643,7 +635,6 @@ with gr.Blocks(title="Graph Generator Pro") as demo:
     preset.change(get_preset_dims, inputs_dims, [width, height])
     topology.change(get_preset_dims, inputs_dims, [width, height])
     
-    # Updated: Now includes topology for default calculation
     inputs_var = [variant, width, height, topology, void_frac]
     variant.change(update_ui_for_variant, inputs_var, [void_frac, t_nodes, t_edges])
     width.change(update_ui_for_variant, inputs_var, [void_frac, t_nodes, t_edges])