Create app.py

app.py

@@ -0,0 +1,745 @@
+import gradio as gr
+import networkx as nx
+import matplotlib.pyplot as plt
+import random
+import time
+import json
+import os
+import shutil
+import zipfile
+from datetime import datetime
+
+# ==========================================
+# 1. JSON EXPORT LOGIC (Adapted from your script)
+# ==========================================
+def prepare_edges_for_json(G):
+    # Sort nodes by X, then Y to ensure consistent IDs
+    # G.nodes() are tuples (x, y)
+    nodes_list = sorted(list(G.nodes()), key=lambda l: (l[0], l[1]))
+    
+    # Map (x,y) -> "1", "2", "3"...
+    nodes_list_dict = {}
+    I = []
+    for idx, node in enumerate(nodes_list):
+        s_id = str(idx + 1)
+        I.append(s_id)
+        nodes_list_dict[s_id] = node
+
+    # Create reverse map for easy lookup
+    coord_to_id = {v: k for k, v in nodes_list_dict.items()}
+
+    edges_list = list(G.edges())
+    edges_formatted = []
+
+    for u, v in edges_list:
+        if u in coord_to_id and v in coord_to_id:
+            edges_formatted.append({
+                "room1": coord_to_id[u],
+                "room2": coord_to_id[v]
+            })
+
+    return edges_formatted, I, nodes_list_dict
+
+def prepare_parameter_for_json(G, I, nodes_list_dict):
+    # Use deterministic randomness based on graph hash or similar if needed, 
+    # but here we use standard random as per requirements.
+    
+    # 1. Weights for dismantling (prefer front rooms)
+    weights = []
+    n_count = len(G.nodes())
+    for i in range(n_count):
+        # Formula from your script
+        val = n_count / (n_count * (1 + (((i + 1) * 2) / 30)))
+        weights.append(val)
+        
+    m_weights = random.choices(I, weights=weights, k=5)
+
+    # 2. Weights for time (prefer early times)
+    t_weights_probs = []
+    for i in range(10):
+        val = n_count / (n_count * (1 + (((i + 1) * 2) / 5)))
+        t_weights_probs.append(val)
+    t_weights = random.choices(range(1, 11), weights=t_weights_probs, k=5)
+
+    dismantled = []
+    conditioningDuration = []
+    assignment = []
+    help_list = []
+
+    # 3. Build Dismantled / Assignment
+    for m in range(5):
+        dismantled.append({"m": str(m + 1), "i": str(m_weights[m]), "t": t_weights[m], "value": 1})
+        conditioningDuration.append({"m": str(m + 1), "value": 1})
+        
+        # Random device selection with fallback logic
+        x = random.randint(1, 3)
+        if m > 2:
+            if 1 not in help_list: x = 1
+            if 2 not in help_list: x = 2
+            if 3 not in help_list: x = 3
+        
+        help_list.append(x)
+        assignment.append({"m": str(m + 1), "r": str(x), "value": 1})
+
+    # 4. Delivery
+    t_weights_del = random.choices(range(1, 11), weights=t_weights_probs[:10], k=3)
+    delivered = []
+    conditioningCapacity = []
+
+    for r in range(3):
+        delivered.append({"r": str(r + 1), "i": "1", "t": t_weights_del[r], "value": 1})
+        conditioningCapacity.append({"r": str(r + 1), "value": 1})
+
+    # 5. Costs
+    CostMT, CostMB, CostRT, CostRB = [], [], [], []
+    
+    for i in range(n_count):
+        s_id = str(i + 1)
+        CostMT.append({"i": s_id, "value": random.choice([2, 5])})
+        CostMB.append({"i": s_id, "value": random.choice([5, 10, 30])})
+        CostRT.append({"i": s_id, "value": random.choice([4, 10])})
+        
+        if i == 0:
+            CostRB.append({"i": s_id, "value": 1000})
+        else:
+            CostRB.append({"i": s_id, "value": random.choice([20, 30, 100])})
+
+    # 6. Coordinates
+    Coord = []
+    # nodes_list_dict maps "1" -> (x,y)
+    for i in range(n_count):
+        s_id = str(i + 1)
+        if s_id in nodes_list_dict:
+            Coord.append({"i": s_id, "Coordinates": nodes_list_dict[s_id]})
+
+    return dismantled, assignment, delivered, conditioningCapacity, conditioningDuration, CostMT, CostMB, CostRT, CostRB, Coord
+
+def generate_full_json_dict(G, loop=0):
+    edges, I, nodes_list_dict = prepare_edges_for_json(G)
+    dismantled, assignment, delivered, condCap, condDur, CostMT, CostMB, CostRT, CostRB, Coord = prepare_parameter_for_json(G, I, nodes_list_dict)
+
+    sets = {
+        "I": I,
+        "E": {"bidirectional": True, "seed": 1, "edges": edges},
+        "M": ["1", "2", "3", "4", "5"],
+        "R": ["1", "2", "3"]
+    }
+    
+    params = {
+        "defaults": {
+            "V": 1000, "dismantled": 0, "delivered": 0,
+            "conditioningCapacity": 1000, "conditioningDuration": 1,
+            "CostMB": 100, "CostMT": 20, "CostRB": 300, "CostRT": 50,
+            "assignment": 0, "dismantled_room_bound": 0,
+            "CostFI": 20, "CostVI": 20
+        },
+        "t_max": 100,
+        "V": [{"m": "1", "i": "1", "value": 42}],
+        "dismantled": dismantled,
+        "delivered": delivered,
+        "conditioningCapacity": condCap,
+        "conditioningDuration": condDur,
+        "assignment": assignment,
+        "CostMT": CostMT, "CostMB": CostMB,
+        "CostRT": CostRT, "CostRB": CostRB,
+        "CostZR": 9, "CostZH": 5,
+        "Coord": Coord
+    }
+    
+    return {"description": "Generated by Gradio Network Generator", "sets": sets, "params": params}
+
+# ==========================================
+# 2. CORE LOGIC: NETWORK GENERATOR CLASS
+# ==========================================
+class NetworkGenerator:
+    def __init__(self, width=10, height=10, variant="F", topology="highly_connected", 
+                 node_drop_fraction=0.1, target_nodes=0, target_edges=0,
+                 bottleneck_cluster_count=None, bottleneck_edges_per_link=1):
+        
+        self.variant = variant.upper() 
+        self.topology = topology.lower()
+        self.width = int(width)
+        self.height = int(height)
+        self.node_drop_fraction = float(node_drop_fraction)
+        
+        # New Target Controls
+        self.target_nodes = int(target_nodes)
+        self.target_edges = int(target_edges)
+
+        self.node_factor = 0.4 
+        if bottleneck_cluster_count is None:
+            area = self.width * self.height
+            self.bottleneck_cluster_count = max(2, int(area / 18))
+        else:
+            self.bottleneck_cluster_count = int(bottleneck_cluster_count)
+            
+        self.bottleneck_edges_per_link = int(bottleneck_edges_per_link)
+        self.graph = None
+        self.active_positions = None 
+
+    def generate(self):
+        max_attempts = 15 
+        for attempt in range(max_attempts):
+            self._build_node_mask()
+            self._initialize_graph()
+            self._add_nodes() # Handles target_nodes logic inside
+
+            nodes = list(self.graph.nodes())
+            if len(nodes) < 2: continue
+
+            # Topology Build
+            if self.topology == "bottlenecks":
+                self._build_bottleneck_clusters(nodes)
+            else:
+                self._connect_all_nodes_by_nearby_growth(nodes)
+                self._add_edges()
+
+            # Cleanup
+            self._remove_intersections()
+            
+            # Post-Processing for Target Edges
+            if self.target_edges > 0:
+                self._adjust_edges_to_target()
+            else:
+                self._enforce_edge_budget()
+
+            if not nx.is_connected(self.graph):
+                self._force_connect_components()
+            
+            self._remove_intersections() 
+            
+            # Final check: if target nodes was set, did we hit it?
+            # (We might miss slightly due to connectivity/intersection constraints, but we accept best effort)
+            
+            if nx.is_connected(self.graph):
+                return self.graph
+
+        raise RuntimeError("Failed to generate valid network. Relax constraints.")
+
+    def _effective_node_drop_fraction(self):
+        # If target nodes is set, drop fraction is ignored/calculated dynamically
+        if self.target_nodes > 0: return 0.0 
+        
+        base = self.node_drop_fraction
+        if self.topology == "highly_connected": return max(0.0, base * 0.8)
+        if self.topology == "linear": return min(0.95, base * 1.2)
+        return base
+
+    def _build_node_mask(self):
+        all_positions = [(x, y) for x in range(self.width + 1) for y in range(self.height + 1)]
+        
+        if self.target_nodes > 0:
+            # If explicit count requested, we don't drop randomly yet. 
+            # We treat all as potentially active, _add_nodes will sample.
+            self.active_positions = set(all_positions)
+        else:
+            drop_frac = self._effective_node_drop_fraction()
+            drop = int(drop_frac * len(all_positions))
+            deactivated = set(random.sample(all_positions, drop)) if drop > 0 else set()
+            self.active_positions = set(all_positions) - deactivated
+
+    def _initialize_graph(self):
+        self.graph = nx.Graph()
+        margin_x = max(1, self.width // 4)
+        margin_y = max(1, self.height // 4)
+        low_x, high_x = margin_x, self.width - margin_x
+        low_y, high_y = margin_y, self.height - margin_y
+        
+        # Prefer middle
+        middle_active = [p for p in self.active_positions if low_x <= p[0] <= high_x and low_y <= p[1] <= high_y]
+        
+        if middle_active: seed = random.choice(middle_active)
+        elif self.active_positions: seed = random.choice(list(self.active_positions))
+        else: return 
+        self.graph.add_node(tuple(seed))
+
+    def _add_nodes(self):
+        # Logic 1: Strict Target Count
+        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 len(available) < needed:
+                # Take all
+                for n in available: self.graph.add_node(n)
+            else:
+                # Sample exact amount
+                chosen = random.sample(available, needed)
+                for n in chosen: self.graph.add_node(n)
+            return
+
+        # Logic 2: Standard Density-based
+        total_possible = (self.width + 1) * (self.height + 1)
+        base = self.node_factor if self.variant == "F" else random.uniform(0.3, 0.6)
+        scale = {"highly_connected": 1.2, "bottlenecks": 0.85, "linear": 0.75}.get(self.topology, 1.0)
+        target = int(base * scale * total_possible)
+        target = min(target, len(self.active_positions))
+        
+        attempts = 0
+        while len(self.graph.nodes()) < target and attempts < (target * 20):
+            attempts += 1
+            x = random.randint(0, self.width)
+            y = random.randint(0, self.height)
+            if (x, y) in self.active_positions and (x, y) not in self.graph:
+                self.graph.add_node((x, y))
+
+    def _connect_all_nodes_by_nearby_growth(self, nodes):
+        connected = set()
+        remaining = set(nodes)
+        if not remaining: return
+        current = random.choice(nodes)
+        connected.add(current)
+        remaining.remove(current)
+
+        while remaining:
+            candidates = []
+            # Optimization: Check nearby only
+            for n in remaining:
+                # Heuristic: check if any connected is close
+                # Full scan is slow for large N, but necessary for correctness
+                closest_dist = min([abs(n[0]-c[0]) + abs(n[1]-c[1]) for c in connected])
+                if closest_dist <= 4: # Manhattan dist check
+                    candidates.append(n)
+            
+            if not candidates:
+                 # Fallback: connect closest pair globally
+                 best_n = min(remaining, key=lambda r: min(abs(r[0]-c[0]) + abs(r[1]-c[1]) for c in connected))
+                 candidates.append(best_n)
+
+            candidate = random.choice(candidates)
+            
+            # Find closest connected node
+            neighbors = sorted(list(connected), key=lambda c: abs(c[0]-candidate[0]) + abs(c[1]-candidate[1]))
+            # Try to connect to closest 3
+            for n in neighbors[:3]:
+                if not self._would_create_intersection(n, candidate):
+                    self.graph.add_edge(n, candidate)
+                    break
+            else:
+                # Force connect closest if no non-intersecting found (will be cleaned later)
+                self.graph.add_edge(neighbors[0], candidate)
+
+            connected.add(candidate)
+            remaining.remove(candidate)
+
+    def _compute_edge_count(self):
+        if self.target_edges > 0: return self.target_edges
+        n = len(self.graph.nodes())
+        if self.topology == "highly_connected": return int(3.5 * n)
+        if self.topology == "bottlenecks": return int(1.8 * n)
+        return int(random.uniform(1.2, 2.0) * n)
+
+    def _add_edges(self):
+        nodes = list(self.graph.nodes())
+        if self.topology == "highly_connected": self._add_cluster_dense(nodes, self._compute_edge_count())
+        elif self.topology == "linear": self._make_linear(nodes)
+
+    def _make_linear(self, nodes):
+        nodes_sorted = sorted(nodes, key=lambda x: (x[0], x[1]))
+        if not nodes_sorted: return
+        prev = nodes_sorted[0]
+        for nxt in nodes_sorted[1:]:
+            if not self._would_create_intersection(prev, nxt): self.graph.add_edge(prev, nxt)
+            prev = nxt
+
+    def _add_cluster_dense(self, nodes, max_edges):
+        edges_added = 0
+        nodes = list(nodes)
+        random.shuffle(nodes)
+        
+        # If target edges set, we might need a lot, so loosen distance
+        dist_limit = 10 if self.target_edges > 0 else 4
+        
+        for i in range(len(nodes)):
+            for j in range(i + 1, len(nodes)):
+                if self.target_edges == 0 and edges_added >= max_edges: return
+                n1, n2 = nodes[i], nodes[j]
+                dist = max(abs(n1[0]-n2[0]), abs(n1[1]-n2[1]))
+                if dist <= dist_limit: 
+                    if not self._would_create_intersection(n1, n2):
+                        self.graph.add_edge(n1, n2)
+                        edges_added += 1
+
+    def _build_bottleneck_clusters(self, nodes):
+        self.graph.remove_edges_from(list(self.graph.edges()))
+        clusters, centers = self._spatial_cluster_nodes(nodes, k=self.bottleneck_cluster_count)
+        for cluster in clusters:
+            if len(cluster) < 2: continue
+            self._connect_cluster_by_nearby_growth(cluster)
+            self._add_cluster_dense(list(cluster), max_edges=max(1, int(3.5 * len(cluster))))
+        order = sorted(range(len(clusters)), key=lambda i: (centers[i][0], centers[i][1]))
+        for a_idx, b_idx in zip(order[:-1], order[1:]):
+            self._add_bottleneck_links(clusters[a_idx], clusters[b_idx], self.bottleneck_edges_per_link)
+        if not nx.is_connected(self.graph): self._force_connect_components()
+
+    def _force_connect_components(self):
+        components = list(nx.connected_components(self.graph))
+        while len(components) > 1:
+            c1, c2 = list(components[0]), list(components[1])
+            best_pair, min_dist = None, float('inf')
+            
+            # Sample for speed if huge
+            s1 = c1 if len(c1)<30 else random.sample(c1, 30)
+            s2 = c2 if len(c2)<30 else random.sample(c2, 30)
+
+            for u in s1:
+                for v in s2:
+                    d = (u[0]-v[0])**2 + (u[1]-v[1])**2
+                    if d < min_dist and not self._would_create_intersection(u, v):
+                        min_dist, best_pair = d, (u, v)
+            
+            if best_pair: self.graph.add_edge(best_pair[0], best_pair[1])
+            else: break # Cannot connect cleanly
+            
+            prev_len = len(components)
+            components = list(nx.connected_components(self.graph))
+            if len(components) == prev_len: break
+
+    def _spatial_cluster_nodes(self, nodes, k):
+        nodes = list(nodes)
+        if k >= len(nodes): return [[n] for n in nodes], nodes[:]
+        centers = random.sample(nodes, k)
+        clusters = [[] for _ in range(k)]
+        for n in nodes:
+            best_i = min(range(k), key=lambda i: max(abs(n[0]-centers[i][0]), abs(n[1]-centers[i][1])))
+            clusters[best_i].append(n)
+        return clusters, centers
+
+    def _connect_cluster_by_nearby_growth(self, cluster_nodes): self._connect_all_nodes_by_nearby_growth(cluster_nodes)
+
+    def _add_bottleneck_links(self, cluster_a, cluster_b, m):
+        pairs = []
+        for u in cluster_a:
+            for v in cluster_b:
+                dist = max(abs(u[0]-v[0]), abs(u[1]-v[1]))
+                pairs.append((dist, u, v))
+        pairs.sort(key=lambda t: t[0])
+        added = 0
+        for _, u, v in pairs:
+            if added >= m: break
+            if not self.graph.has_edge(u, v) and not self._would_create_intersection(u, v): 
+                self.graph.add_edge(u, v)
+                added += 1
+
+    def _remove_intersections(self):
+        # Full check
+        pass_no = 0
+        while pass_no < 5:
+            pass_no += 1
+            edges = list(self.graph.edges())
+            intersections = []
+            # Check subset if massive
+            if len(edges) > 600:
+                check_edges = random.sample(edges, 400)
+            else:
+                check_edges = edges
+
+            for i in range(len(check_edges)):
+                for j in range(i+1, len(check_edges)):
+                    e1, e2 = check_edges[i], check_edges[j]
+                    if self._segments_intersect(e1[0], e1[1], e2[0], e2[1]): intersections.append((e1, e2))
+            
+            if not intersections: break
+            for e1, e2 in intersections:
+                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
+                self.graph.remove_edge(e1 if l1 > l2 else e2)
+
+    def _adjust_edges_to_target(self):
+        # If target_edges is set, we strictly add or remove
+        current_edges = list(self.graph.edges())
+        curr_count = len(current_edges)
+        
+        # Case 1: Too many
+        if curr_count > self.target_edges:
+            to_remove = curr_count - self.target_edges
+            # remove longest first
+            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) # Put it back if it breaks connectivity
+
+        # Case 2: Too few
+        elif curr_count < self.target_edges:
+            needed = self.target_edges - curr_count
+            nodes = list(self.graph.nodes())
+            attempts = 0
+            while len(self.graph.edges()) < self.target_edges and attempts < (needed * 20):
+                attempts += 1
+                u, v = random.sample(nodes, 2)
+                if not self.graph.has_edge(u, v) and not self._would_create_intersection(u, v):
+                    # Check distance sanity (don't connect across map randomly unless desperate)
+                    dist = abs(u[0]-v[0]) + abs(u[1]-v[1])
+                    if dist < max(self.width, self.height) / 2: 
+                        self.graph.add_edge(u, v)
+
+    def _enforce_edge_budget(self):
+        budget = self._compute_edge_count()
+        while len(self.graph.edges()) > budget:
+            edges = list(self.graph.edges())
+            rem = random.choice(edges)
+            self.graph.remove_edge(*rem)
+            if not nx.is_connected(self.graph):
+                self.graph.add_edge(*rem)
+                break 
+
+    def _segments_intersect(self, a, b, c, d):
+        if a == c or a == d or b == c or b == d: return False
+        def ccw(A,B,C): return (C[1]-A[1]) * (B[0]-A[0]) > (B[1]-A[1]) * (C[0]-A[0])
+        return ccw(a,c,d) != ccw(b,c,d) and ccw(a,b,c) != ccw(a,b,d)
+
+    def _would_create_intersection(self, u, v):
+        for a, b in self.graph.edges():
+            if u == a or u == b or v == a or v == b: continue
+            if self._segments_intersect(u, v, a, b): return True
+        return False
+
+    # === MANUAL EDITING METHODS ===
+    def manual_add_node(self, x, y):
+        # 1. Check bounds
+        if not (0 <= x <= self.width and 0 <= y <= self.height):
+            return False, "Coordinates out of bounds."
+        # 2. Check existence
+        if self.graph.has_node((x, y)):
+            return False, "Node already exists."
+        
+        self.graph.add_node((x, y))
+        # Connect to nearest neighbor to maintain connectivity
+        nodes = list(self.graph.nodes())
+        if len(nodes) > 1:
+            # find closest
+            closest = min([n for n in nodes if n != (x,y)], 
+                          key=lambda n: (n[0]-x)**2 + (n[1]-y)**2)
+            if not self._would_create_intersection((x,y), closest):
+                self.graph.add_edge((x,y), closest)
+        
+        return True, "Node added."
+
+    def manual_delete_node(self, x, y):
+        if not self.graph.has_node((x, y)):
+            return False, "Node does not exist."
+        
+        self.graph.remove_node((x, y))
+        
+        # Check connectivity
+        if len(self.graph.nodes()) > 1 and not nx.is_connected(self.graph):
+             # Try to repair? Or just warn?
+             # For manual edits, we usually allow disjoint temporarily, 
+             # but let's try to reconnect components
+             self._force_connect_components()
+             
+        return True, "Node removed."
+
+
+# ==========================================
+# GRADIO HELPERS
+# ==========================================
+
+def plot_graph(graph, width, height, title="Network"):
+    fig, ax = plt.subplots(figsize=(8, 8))
+    pos = {node: (node[0], node[1]) for node in graph.nodes()}
+    
+    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)
+    
+    # Label mapping (coord -> id) to match JSON output
+    # Sort by X, Y
+    sorted_nodes = sorted(list(graph.nodes()), key=lambda l: (l[0], l[1]))
+    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() 
+    ax.grid(True, linestyle=':', alpha=0.3)
+    ax.set_axis_on()
+    ax.tick_params(left=True, bottom=True, labelleft=False, labelbottom=False)
+    ax.set_title(title)
+    return fig
+
+def get_preset_dims(preset_mode, topology):
+    if preset_mode == "Custom":
+        return gr.update(interactive=True), gr.update(interactive=True)
+    if topology == "linear":
+        dims = (4, 4) if preset_mode == "Small" else (6, 11) if preset_mode == "Medium" else (10, 26)
+    else: 
+        dims = (4, 4) if preset_mode == "Small" else (8, 8) if preset_mode == "Medium" else (16, 16)
+    return gr.update(value=dims[0], interactive=False), gr.update(value=dims[1], interactive=False)
+
+def update_void_settings(variant, width, height):
+    if variant == "Custom": return gr.update(interactive=True)
+    area = width * height
+    val = 0.60 if area <= 20 else 0.35
+    return gr.update(value=val, interactive=False)
+
+# STATE HANDLER
+def generate_and_store(topology, width, height, variant, void_frac, t_nodes, t_edges):
+    try:
+        var_code = "F" if variant == "Fixed" else "R"
+        gen = NetworkGenerator(width, height, var_code, topology, void_frac, t_nodes, t_edges)
+        graph = gen.generate()
+        
+        fig = plot_graph(graph, width, height, f"{topology} ({len(graph.nodes())}N, {len(graph.edges())}E)")
+        
+        metrics = f"**Nodes:** {len(graph.nodes())} | **Edges:** {len(graph.edges())} | **Density:** {nx.density(graph):.2f}"
+        
+        # Store graph and params in state
+        state_data = {
+            "graph": graph,
+            "width": width,
+            "height": height,
+            "topology": topology
+        }
+        return fig, metrics, state_data, gr.update(interactive=True) # Enable edit/save
+    except Exception as e:
+        return None, f"Error: {e}", None, gr.update(interactive=False)
+
+def manual_edit_action(action, x, y, state_data):
+    if not state_data or "graph" not in state_data:
+        return None, "No graph generated yet.", state_data
+    
+    graph = state_data["graph"]
+    width = state_data["width"]
+    height = state_data["height"]
+    
+    # We need a wrapper to call manual methods
+    # (Since methods are on class instance, but we only stored graph. 
+    # We can briefly instantiate class or just modify graph directly using class logic methods)
+    # Re-instantiating is safer for accessing helper methods
+    
+    gen = NetworkGenerator(width, height) 
+    gen.graph = graph 
+    
+    if action == "Add Node":
+        success, msg = gen.manual_add_node(int(x), int(y))
+    else:
+        success, msg = gen.manual_delete_node(int(x), int(y))
+        
+    if success:
+        fig = plot_graph(gen.graph, width, height, f"Edited ({len(gen.graph.nodes())}N)")
+        metrics = f"**Nodes:** {len(gen.graph.nodes())} | **Edges:** {len(gen.graph.edges())} | {msg}"
+        state_data["graph"] = gen.graph # Update state
+        return fig, metrics, state_data
+    else:
+        return gr.update(), f"Error: {msg}", state_data
+
+def batch_save_action(count, state_data):
+    if not state_data: return None
+    
+    # We reconstruct the parameters from the state (or UI inputs if passed)
+    # For batch, users usually want variations of the CURRENT settings.
+    # However, Gradio state only stored the Graph. We need the original params.
+    # To keep it simple: We will just re-generate purely new graphs based on CURRENT UI inputs inside the loop.
+    return None # Placeholder, logic moved to UI event for access to inputs
+
+def run_batch_generation(count, topology, width, height, variant, void_frac, t_nodes, t_edges):
+    # Temp dir
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    dir_name = f"batch_output_{timestamp}"
+    os.makedirs(dir_name, exist_ok=True)
+    
+    var_code = "F" if variant == "Fixed" else "R"
+    
+    try:
+        for i in range(int(count)):
+            gen = NetworkGenerator(width, height, var_code, topology, void_frac, t_nodes, t_edges)
+            G = gen.generate()
+            
+            # Create JSON content
+            json_content = generate_full_json_dict(G, loop=i+1)
+            
+            fname = f"instance_{timestamp}_{i+1}.json"
+            with open(os.path.join(dir_name, fname), 'w') as f:
+                json.dump(json_content, f, indent=4)
+        
+        # Zip it
+        zip_filename = f"{dir_name}.zip"
+        shutil.make_archive(dir_name, 'zip', dir_name)
+        
+        # Cleanup temp folder
+        shutil.rmtree(dir_name)
+        
+        return f"{dir_name}.zip"
+    except Exception as e:
+        return None
+
+# ==========================================
+# GRADIO UI LAYOUT
+# ==========================================
+with gr.Blocks(title="Graph Generator Pro") as demo:
+    state = gr.State() # Stores current graph object
+    
+    gr.Markdown("# Spatial Network Generator Pro")
+    
+    with gr.Row():
+        # LEFT: Settings
+        with gr.Column(scale=1):
+            with gr.Tab("Config"):
+                topology = gr.Dropdown(["highly_connected", "bottlenecks", "linear"], value="highly_connected", label="Topology")
+                preset = gr.Radio(["Small", "Medium", "Large", "Custom"], value="Medium", label="Preset")
+                
+                with gr.Row():
+                    width = gr.Number(8, label="Width", precision=0, interactive=False)
+                    height = gr.Number(8, label="Height", precision=0, interactive=False)
+                
+                variant = gr.Dropdown(["Fixed", "Custom"], value="Fixed", label="Variant")
+                void_frac = gr.Slider(0.0, 0.9, 0.35, step=0.05, label="Void Fraction", interactive=False)
+                
+                gr.Markdown("### Overrides (Optional)")
+                t_nodes = gr.Number(0, label="Target Node Count (0=Auto)", precision=0)
+                t_edges = gr.Number(0, label="Target Edge Count (0=Auto)", precision=0)
+                
+                gen_btn = gr.Button("Generate Network", variant="primary")
+
+            with gr.Tab("Editor"):
+                gr.Markdown("Modify the current graph manually.")
+                with gr.Row():
+                    ed_x = gr.Number(0, label="X", precision=0)
+                    ed_y = gr.Number(0, label="Y", precision=0)
+                
+                with gr.Row():
+                    btn_add = gr.Button("Add Node")
+                    btn_del = gr.Button("Delete Node")
+
+            with gr.Tab("Batch Export"):
+                gr.Markdown("Generate multiple variations and save as JSONs.")
+                batch_count = gr.Slider(1, 50, 5, step=1, label="Number of Variations")
+                batch_btn = gr.Button("Generate & Download Batch ZIP")
+                file_out = gr.File(label="Download")
+
+        # RIGHT: Visualization
+        with gr.Column(scale=2):
+            metrics = gr.Markdown("Ready.")
+            plot = gr.Plot()
+
+    # EVENTS
+    
+    # 1. Preset & Void Logic
+    inputs_dims = [preset, topology]
+    preset.change(get_preset_dims, inputs_dims, [width, height])
+    topology.change(get_preset_dims, inputs_dims, [width, height])
+    
+    inputs_void = [variant, width, height]
+    variant.change(update_void_settings, inputs_void, [void_frac])
+    width.change(update_void_settings, inputs_void, [void_frac])
+    height.change(update_void_settings, inputs_void, [void_frac])
+
+    # 2. Generation
+    gen_args = [topology, width, height, variant, void_frac, t_nodes, t_edges]
+    gen_btn.click(generate_and_store, gen_args, [plot, metrics, state])
+
+    # 3. Manual Editing
+    btn_add.click(manual_edit_action, [gr.State("Add Node"), ed_x, ed_y, state], [plot, metrics, state])
+    btn_del.click(manual_edit_action, [gr.State("Del Node"), ed_x, ed_y, state], [plot, metrics, state])
+
+    # 4. Batch
+    batch_args = [batch_count, topology, width, height, variant, void_frac, t_nodes, t_edges]
+    batch_btn.click(run_batch_generation, batch_args, [file_out])
+
+if __name__ == "__main__":
+    demo.launch()