Update app.py

app.py

@@ -23,6 +23,14 @@ DEFAULTS = {
 
 # ---------- Hypercube utilities ----------
 
+def index_in_path(path: List[int], vid: int):
+    """Return the index of vid in path (first occurrence), or None."""
+    try:
+        return path.index(vid)
+    except ValueError:
+        return None
+
+
 def swap_dims_vertex(v: int, i: int, j: int) -> int:
     """
     Swap bits i and j in the vertex id v.
@@ -499,7 +507,7 @@ app.layout = html.Div(
         html.Div(id="stats", style={"opacity": 0.7, "marginBottom": "0px"}),
 
         html.Div(
-            style={"display": "grid", "gridTemplateColumns": "1fr 1fr 1fr", "gap": "8px", "marginTop": "20px"},
+            style={"display": "grid", "gridTemplateColumns": "1fr 1fr 1fr 1fr", "gap": "8px", "marginTop": "20px"},
             children=[
                 html.Div([
                     html.Label("Dimension d"),
@@ -552,6 +560,30 @@ app.layout = html.Div(
                         labelStyle={"display": "inline-block","background-color": "yellow"}
                     ),
                 ]),
+                
+                # --- Subpath flip controls ---
+                html.Div(
+                    style={"display": "flex", "gap": "8px", "alignItems": "center", "marginBottom": "8px"},
+                    children=[
+                        html.Button("Flip subpath (2 clicks)", id="btn_flip_subpath", n_clicks=0,
+                                    style={"background": "#2563EB", "color": "white"}),
+                        dcc.Input(
+                            id="subpath_dim",
+                            type="number",
+                            min=0,
+                            step=1,
+                            value=0,
+                            placeholder="dimension i",
+                            style={"width": "130px"},
+                        ),
+                        html.Span(id="subpath_status", style={"opacity": 0.8}),
+                    ],
+                ),
+                
+                dcc.Store(
+                    id="subpath_select_store",
+                    data={"active": False, "start_idx": None, "end_idx": None}
+                ),
 
                 html.Div(),  # empty cell just to keep the grid tidy
             ],
@@ -654,6 +686,7 @@ def stats(d, path):
 
 @app.callback(
     Output("path_store", "data"),
+    Output("subpath_select_store", "data"),         # NEW
     Input("fig", "clickData"),
     Input("btn_clear", "n_clicks"),
     Input("btn_longest_cib", "n_clicks"),
@@ -661,12 +694,15 @@ def stats(d, path):
     Input("btn_set", "n_clicks"),
     Input("btn_swap", "n_clicks"),
     Input("btn_flip", "n_clicks"),
+    Input("btn_flip_subpath", "n_clicks"),          # NEW
     State("path_store", "data"),
     State("manual_path", "value"),
     State("dim", "value"),
     State("swap_i", "value"),
     State("swap_j", "value"),
     State("flip_k", "value"),
+    State("subpath_select_store", "data"),          # NEW
+    State("subpath_dim", "value"),                  # NEW
     prevent_initial_call=True
 )
 def update_path(clickData,
@@ -676,101 +712,164 @@ def update_path(clickData,
                 n_set,
                 n_swap,
                 n_flip,
+                n_flip_subpath,
                 path,
                 manual_text,
                 d,
                 swap_i,
                 swap_j,
-                flip_k):
+                flip_k,
+                subsel,
+                subpath_dim):
+
     trigger = ctx.triggered_id
     path = path or []
     d = int(d)
 
+    # default selection store
+    subsel = subsel or {"active": False, "start_idx": None, "end_idx": None}
 
     # 1) Clear
     if trigger == "btn_clear":
-        return []
+        return [], {"active": False, "start_idx": None, "end_idx": None}
 
     # 2a) Longest CIB
     if trigger == "btn_longest_cib":
-        return longest_cib(d)
+        return longest_cib(d), {"active": False, "start_idx": None, "end_idx": None}
 
     # 2b) Shorter CIB
     if trigger == "btn_shorter_cib":
-        return shorter_cib(d)
+        return shorter_cib(d), {"active": False, "start_idx": None, "end_idx": None}
 
     # 3) Manual set path
     if trigger == "btn_set":
         newp = parse_path(manual_text or "", d)
-        return newp if newp else path
+        return (newp if newp else path), {"active": False, "start_idx": None, "end_idx": None}
 
-    # 4) Swap two dimensions (apply to entire path)
+    # 4) Swap two dimensions
     if trigger == "btn_swap":
         try:
             i = int(swap_i) if swap_i is not None else None
             j = int(swap_j) if swap_j is not None else None
         except (TypeError, ValueError):
-            return path
+            return path, subsel
         if i is None or j is None:
-            return path
-        # clamp to valid range
+            return path, subsel
         if not (0 <= i < d and 0 <= j < d):
-            return path
-        return swap_dims_path(path, d, i, j)
+            return path, subsel
+        return swap_dims_path(path, d, i, j), subsel
 
-    # 5) Flip one dimension (apply to entire path)
+    # 5) Flip one dimension (whole path)
     if trigger == "btn_flip":
         try:
             k = int(flip_k) if flip_k is not None else None
         except (TypeError, ValueError):
-            return path
+            return path, subsel
         if k is None or not (0 <= k < d):
-            return path
-        return flip_dim_path(path, d, k)
-
-
-    # 6) Figure clicks: vertex (int) or edge ([u,v])
+            return path, subsel
+        return flip_dim_path(path, d, k), subsel
+
+    # 6) The new two-click button:
+    #    First click: enter selection mode.
+    #    Second click: apply flip on the selected subpath and exit mode.
+    if trigger == "btn_flip_subpath":
+        active = bool(subsel.get("active"))
+        if not active:
+            # enter selection mode
+            return path, {"active": True, "start_idx": None, "end_idx": None}
+
+        # active == True, so this is the "second click": apply
+        try:
+            i = int(subpath_dim) if subpath_dim is not None else None
+        except (TypeError, ValueError):
+            i = None
+        if i is None or not (0 <= i < d):
+            # invalid dimension, just exit selection mode
+            return path, {"active": False, "start_idx": None, "end_idx": None}
+
+        s = subsel.get("start_idx")
+        e = subsel.get("end_idx")
+        if s is None or e is None or e <= s:
+            # nothing meaningful selected, exit
+            return path, {"active": False, "start_idx": None, "end_idx": None}
+
+        # subpath is path[s:e+1] = (v1,...,vk)
+        # requirement: remove v2..vk and replace them with flipped(v2..vk)
+        # so v1 stays as-is, and we replace the tail of the selected subpath.
+        head = path[:s + 1]
+        tail_selected = path[s + 1:e + 1]  # v2..vk
+        flipped_tail = [flip_dim_vertex(v, i) for v in tail_selected]
+        rest = path[e + 1:]
+        new_path = head + flipped_tail + rest
+
+        return new_path, {"active": False, "start_idx": None, "end_idx": None}
+
+    # 7) Figure clicks
     if trigger == "fig" and clickData and clickData.get("points"):
         p = clickData["points"][0]
         cd = p.get("customdata")
 
-        # Vertex click → add if adjacent, else restart
+        # If we're in subpath selection mode, vertex clicks define (start_idx, end_idx)
+        if subsel.get("active") and isinstance(cd, (int, float)):
+            vid = int(cd)
+            idx = index_in_path(path, vid)
+            if idx is None:
+                return path, subsel
+
+            s = subsel.get("start_idx")
+            e = subsel.get("end_idx")
+
+            # first selected vertex
+            if s is None:
+                return path, {"active": True, "start_idx": idx, "end_idx": idx}
+
+            # enforce consecutive forward selection along the path
+            # user must click idx == e+1 to extend
+            if e is None:
+                e = s
+            if idx == e + 1:
+                return path, {"active": True, "start_idx": s, "end_idx": idx}
+
+            # allow shrinking by clicking the current end again
+            if idx == e:
+                # pop last selected (shrink by 1) if possible
+                new_e = e - 1 if e > s else s
+                return path, {"active": True, "start_idx": s, "end_idx": new_e}
+
+            # otherwise ignore
+            return path, subsel
+
+        # Normal mode: your existing click-to-build-path behavior
         if isinstance(cd, (int, float)):
             vid = int(cd)
 
-            # If no path yet → start it
             if not path:
-                return [vid]
+                return [vid], subsel
 
-            # If clicked the *last* vertex again → remove it (un-click)
             if vid == path[-1]:
-                return path[:-1]
+                return path[:-1], subsel
 
-            # If clicked a vertex that is directly before the last one → also allow backtracking
             if len(path) >= 2 and vid == path[-2]:
-                return path[:-1]
+                return path[:-1], subsel
 
-            # Otherwise, if adjacent to last vertex → extend path
             if hamming_dist(vid, path[-1]) == 1:
-                return path + [vid]
+                return path + [vid], subsel
 
-            # Otherwise not adjacent → start a new path from this vertex
-            return [vid]
+            return [vid], subsel
 
-
-        # Edge click → add other endpoint if extending current endpoint
         if isinstance(cd, (list, tuple)) and len(cd) == 2:
             u, v = int(cd[0]), int(cd[1])
             if not path:
-                return [u, v]
+                return [u, v], subsel
             last = path[-1]
             if last == u:
-                return path + [v]
+                return path + [v], subsel
             if last == v:
-                return path + [u]
-            return [u, v]
+                return path + [u], subsel
+            return [u, v], subsel
+
+    return path, subsel
 
-    return path
 
 @app.callback(
     Output("fig", "figure"),
@@ -881,6 +980,21 @@ def path_bits_view(d, path, show_labels_vals):
         style={"margin": 0},
     )
 
+@app.callback(
+    Output("subpath_status", "children"),
+    Input("subpath_select_store", "data"),
+)
+def subpath_status(subsel):
+    subsel = subsel or {"active": False, "start_idx": None, "end_idx": None}
+    if not subsel.get("active"):
+        return "Idle"
+    s = subsel.get("start_idx")
+    e = subsel.get("end_idx")
+    if s is None:
+        return "Selection: click a vertex on the current path to start"
+    if e is None or e == s:
+        return f"Selection: start at index {s}. Click the next path vertex to extend"
+    return f"Selection: indices {s}..{e}. Click next vertex to extend, then click the button again to apply"
 
     
 if __name__ == "__main__":