Update state.py

state.py

@@ -55,7 +55,6 @@ def init_session_state():
         "speakerSegments":  {},   # {filename: {speaker: [(start,end), ...]}}
         "speakerWaveforms": {},   # {filename: (waveform_tensor, sample_rate)}
         "globalRenames":    [],   # [{"name": str, "speakers": ["file: SPEAKER_##", ...]}]
-        "globally_tracked_tokens": set(),  # tokens ever assigned via globalRenames
         "analyzeAllToggle": False,
     }
     for key, value in defaults.items():
@@ -139,78 +138,34 @@ def updateCategoryOptions():
 # Global rename callbacks
 # ---------------------------------------------------------------------------
 
+# ---------------------------------------------------------------------------
+# Global rename helpers
+# ---------------------------------------------------------------------------
+
 def _global_rename_key(index):
     return f"grename_speakers_{index}"
 
 
-def applyGlobalRenames():
-    """Sync speakerRenames (and inline tab widget keys) from globalRenames.
-
-    Uses `globally_tracked_tokens` as a graveyard: any token ever assigned
-    via globalRenames is recorded there.  On each call:
-      - token currently assigned  → rename to the entry's name
-      - token in graveyard but NOT currently assigned → revert to raw label
-      - token never touched by globalRenames → leave speakerRenames untouched
-                                               (inline-only rename)
+def _write_rename(token, name):
+    """Write name into speakerRenames for a single token (fname: SPEAKER_##).
+    If name is empty, clears the entry (revert to raw label).
+    Silently ignores tokens that don't match a known file.
     """
-    # Build map of currently-assigned token -> name
-    token_to_name: dict = {}
-    for entry in st.session_state.globalRenames:
-        for token in entry["speakers"]:
-            token_to_name[token] = entry["name"]
-
-    # Update the graveyard with any newly assigned tokens
-    st.session_state.globally_tracked_tokens.update(token_to_name.keys())
-
-    # 1. Update speakerRenames for tokens already in the graveyard
-    for fname in list(st.session_state.speakerRenames.keys()):
-        renames = st.session_state.speakerRenames[fname]
-        for sp in list(renames.keys()):
-            token = f"{fname}: {sp}"
-            if token in token_to_name:
-                # Currently assigned — apply the name
-                renames[sp] = token_to_name[token]
-            elif token in st.session_state.globally_tracked_tokens:
-                # Was global but is now unassigned — revert to raw label
-                del renames[sp]
-            # else: purely inline rename — leave untouched
-
-    # 2. Apply newly assigned tokens not yet in speakerRenames
-    for token, name in token_to_name.items():
-        if ": " not in token:
-            continue
-        fname, raw_sp = token.split(": ", 1)
-        if fname in st.session_state.speakerRenames:
-            st.session_state.speakerRenames[fname][raw_sp] = name
-
-    # 3. Sync inline-tab widget keys so Rename Speaker tab reflects changes
-    for fname, renames in st.session_state.speakerRenames.items():
-        results = st.session_state.results.get(fname)
-        if not results or len(results) != 2:
-            continue
-        for sp in results[0].labels():
-            st.session_state[f"rename_{fname}_{sp}"] = renames.get(sp, "")
-
-
-def enforceGlobalRenameExclusivity(changed_idx):
-    """Ensure a token assigned to entry[changed_idx] is removed from all others."""
-    changed_tokens = set(st.session_state.globalRenames[changed_idx]["speakers"])
-    for idx, entry in enumerate(st.session_state.globalRenames):
-        if idx == changed_idx:
-            continue
-        new_speakers = [t for t in entry["speakers"] if t not in changed_tokens]
-        if new_speakers != entry["speakers"]:
-            entry["speakers"] = new_speakers
-            # Clear widget key so it re-seeds from updated entry data on next render
-            st.session_state.pop(_global_rename_key(idx), None)
-    applyGlobalRenames()
+    if ": " not in token:
+        return
+    fname, raw_sp = token.split(": ", 1)
+    if fname not in st.session_state.speakerRenames:
+        return  # token references an unknown file — ignore
+    if name:
+        st.session_state.speakerRenames[fname][raw_sp] = name
+    else:
+        st.session_state.speakerRenames[fname].pop(raw_sp, None)
 
 
 def addGlobalRename():
     new_name = st.session_state.globalRenameInput.strip()
     if not new_name:
         return
-    # Don't create a duplicate entry — if the name already exists just clear the input
     for entry in st.session_state.globalRenames:
         if entry["name"] == new_name:
             st.toast(f"'{new_name}' already exists in the rename list")
@@ -218,69 +173,96 @@ def addGlobalRename():
             return
     st.toast(f"Adding rename '{new_name}'")
     st.session_state.globalRenames.append({"name": new_name, "speakers": []})
-    # Don't pre-seed the widget key here — the render loop will seed it from
-    # entry["speakers"] on the next pass, which avoids any widget-mutation error.
     st.session_state.globalRenameInput = ""
 
 
 def removeGlobalRename(index):
     entry = st.session_state.globalRenames[index]
     st.toast(f"Removing rename '{entry['name']}'")
-    # Clear the widget key for the deleted entry so Streamlit doesn't try to
-    # render it after it no longer exists in globalRenames.
+    # Revert every speaker that belonged to this entry
+    for token in entry["speakers"]:
+        _write_rename(token, "")
     st.session_state.pop(_global_rename_key(index), None)
     del st.session_state.globalRenames[index]
-    # Shift remaining widget keys down by one position
+    # Shift remaining widget keys down
     for i in range(index, len(st.session_state.globalRenames)):
         st.session_state[_global_rename_key(i)] = list(
             st.session_state.globalRenames[i]["speakers"]
         )
-    applyGlobalRenames()
 
 
 def apply_inline_rename(currFile, raw_sp, new_name):
-    """Write a single inline rename into both speakerRenames and globalRenames.
+    """Write a rename from the Rename Speaker tab into speakerRenames and globalRenames.
 
-    Keeps the sidebar global-rename list in sync so applyGlobalRenames()
-    won't overwrite the change on the next rerun.  Also syncs the inline-tab
-    widget key so the Rename Speaker tab reflects the result immediately.
+    - Removes the token from any existing globalRenames entry first (exclusivity).
+    - If new_name is non-empty: writes the rename and upserts a globalRenames entry.
+    - If new_name is empty: clears the rename (revert to SPEAKER_##).
     """
     new_name = new_name.strip()
     token = f"{currFile}: {raw_sp}"
 
-    # Remove this token from every existing globalRenames entry first — a token
-    # must belong to at most one name.  Clear the sidebar widget key so it
-    # re-seeds from the updated entry data on the next render pass.
+    # Remove from any existing globalRenames entry
     for idx, entry in enumerate(st.session_state.globalRenames):
         if token in entry["speakers"]:
             entry["speakers"].remove(token)
             st.session_state.pop(_global_rename_key(idx), None)
 
     if new_name:
-        # Write into speakerRenames immediately
-        st.session_state.speakerRenames.setdefault(currFile, {})[raw_sp] = new_name
-        # Sync the inline-tab text widget so the tab shows the confirmed name
-        st.session_state[f"rename_{currFile}_{raw_sp}"] = new_name
-        # Record this token as globally tracked so applyGlobalRenames can
-        # revert it if it's ever removed from globalRenames.
-        st.session_state.globally_tracked_tokens.add(token)
-        # Find an existing globalRenames entry for this name, or create one
+        _write_rename(token, new_name)
+        # Upsert a globalRenames entry for this name
         for idx, entry in enumerate(st.session_state.globalRenames):
             if entry["name"] == new_name:
                 entry["speakers"].append(token)
                 st.session_state.pop(_global_rename_key(idx), None)
                 return
-        # No existing entry — create a new one; don't pre-set widget key,
-        # the render loop will seed it from entry["speakers"] on the next pass.
         st.session_state.globalRenames.append({"name": new_name, "speakers": [token]})
     else:
-        # Empty name — revert this speaker back to its raw label.
-        st.session_state.speakerRenames.setdefault(currFile, {}).pop(raw_sp, None)
-        # Clear the inline-tab text widget so the tab shows the raw SPEAKER_## label
-        st.session_state[f"rename_{currFile}_{raw_sp}"] = ""
-        # Remove from graveyard so a future inline rename on the same speaker
-        # is treated as a fresh inline-only rename (not subject to global revert).
-        st.session_state.globally_tracked_tokens.discard(token)
+        _write_rename(token, "")
+        st.toast(f"Reverted {raw_sp} to original label")
+
+
+def on_grename_change(idx):
+    """Callback for the sidebar rename multiselect at position idx.
+
+    Diffs old vs new speakers list:
+    - Newly added tokens → enforce exclusivity across other entries (evict + revert
+      their old name), then write this entry's name into speakerRenames.
+    - Removed tokens → clear speakerRenames for those tokens (revert to SPEAKER_##).
+    """
+    grkey = _global_rename_key(idx)
+    entry = st.session_state.globalRenames[idx]
+    name  = entry["name"]
+
+    prev = set(entry["speakers"])
+    new  = set(st.session_state.get(grkey, []))
+
+    added   = new - prev
+    removed = prev - new
+
+    # Write the new speakers list to the data model (keep stable order: prev kept +
+    # new additions appended, so the multiselect doesn't jump around)
+    kept = [t for t in entry["speakers"] if t in new]
+    entry["speakers"] = kept + [t for t in added]
+    # Pop widget key so it re-seeds cleanly from entry["speakers"] on next render
+    st.session_state.pop(grkey, None)
+
+    # Enforce exclusivity and apply renames for newly added tokens
+    for token in added:
+        # Evict token from every other entry and revert its old name
+        for other_idx, other_entry in enumerate(st.session_state.globalRenames):
+            if other_idx == idx:
+                continue
+            if token in other_entry["speakers"]:
+                other_entry["speakers"].remove(token)
+                st.session_state.pop(_global_rename_key(other_idx), None)
+                # Revert the old name before we overwrite with the new one
+                _write_rename(token, "")
+        # Now write the new name
+        _write_rename(token, name)
+
+    # Revert speakerRenames for tokens that were removed from this entry
+    for token in removed:
+        _write_rename(token, "")
 
 
 # ---------------------------------------------------------------------------
@@ -293,18 +275,10 @@ def updateMultiSelect():
     result = st.session_state.results.get(fileName)
     if not result:
         return
-    currAnnotation, _ = result
-    speakerNames  = list(currAnnotation.labels())
-    saved_renames = st.session_state.speakerRenames.get(fileName, {})
-    for sp in speakerNames:
-        saved = saved_renames.get(sp, "")
-        st.session_state[f"rename_{fileName}_{sp}"] = saved
     # Pop category widget keys so they re-seed from categorySelect data
     for category in st.session_state.categories:
         st.session_state.pop(f"multiselect_{category}", None)
-    # Pop globalRenames widget keys so they re-seed from entry["speakers"] data.
-    # This prevents a file-switch from leaving stale selections in the sidebar
-    # rename multiselects.
+    # Pop globalRenames widget keys so they re-seed from entry["speakers"] data
     for i in range(len(st.session_state.globalRenames)):
         st.session_state.pop(_global_rename_key(i), None)