Update state.py

state.py

@@ -55,6 +55,7 @@ def init_session_state():
         "speakerSegments":  {},   # {filename: {speaker: [(start,end), ...]}}
         "speakerWaveforms": {},   # {filename: (waveform_tensor, sample_rate)}
         "globalRenames":    [],   # [{"name": str, "speakers": ["file: SPEAKER_##", ...]}]
+        "inlineRenames":    {},   # {filename: {speaker: name}} — set by Rename Speaker tab only
         "analyzeAllToggle": False,
     }
     for key, value in defaults.items():
@@ -143,73 +144,48 @@ def _global_rename_key(index):
 
 
 def applyGlobalRenames():
-    """Sync speakerRenames from globalRenames without clobbering inline-only renames.
-    DEBUG VERSION.
-
-    Strategy: only touch speakers whose token appears in globalRenames. Speakers
-    with no globalRenames entry keep whatever speakerRenames already has for them
-    (set by apply_inline_rename). This prevents the sidebar from wiping a rename
-    that was made via the Rename Speaker tab but whose token was later removed from
-    a globalRenames entry.
+    """Rebuild speakerRenames from two independent sources:
+      1. globalRenames  — sidebar assignments (always authoritative for tokens it covers)
+      2. inlineRenames  — Rename Speaker tab assignments (used only when globalRenames
+                          has no claim on that token)
+    Any speaker not covered by either source gets cleared.
     """
-    print(f"[DEBUG applyGlobalRenames] globalRenames={st.session_state.globalRenames}")
-    print(f"[DEBUG applyGlobalRenames] speakerRenames before={st.session_state.speakerRenames}")
-    # Build a map of token -> display_name from globalRenames
+    # Build token->name map from globalRenames
     token_to_name: dict = {}
     for entry in st.session_state.globalRenames:
         for token in entry["speakers"]:
             token_to_name[token] = entry["name"]
 
-    # Collect every token that exists in ANY globalRenames entry (assigned or not)
-    all_global_tokens: set = {
-        token
-        for entry in st.session_state.globalRenames
-        for token in entry["speakers"]
-    }
-
+    # Rebuild speakerRenames for every file from scratch
     for fname in st.session_state.speakerRenames:
-        renames = st.session_state.speakerRenames[fname]
-        for sp in list(renames.keys()):
+        new_renames = {}
+        inline = st.session_state.inlineRenames.get(fname, {})
+        # Check every known speaker for this file
+        result = st.session_state.results.get(fname)
+        if not result or len(result) != 2:
+            continue
+        for sp in result[0].labels():
             token = f"{fname}: {sp}"
             if token in token_to_name:
-                # Overwrite with the current globalRenames name
-                renames[sp] = token_to_name[token]
-            elif token in all_global_tokens:
-                # Token was explicitly unassigned from all entries — clear the rename
-                del renames[sp]
-            # else: inline-only rename with no globalRenames record — leave untouched
-
-    # Apply any 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
-
-    print(f"[DEBUG applyGlobalRenames] speakerRenames after={st.session_state.speakerRenames}")
-    curr = st.session_state.get("select_currFile")
-    if curr and curr in st.session_state.speakerRenames:
-        saved   = st.session_state.speakerRenames[curr]
-        results = st.session_state.results.get(curr)
-        if results:
-            for sp in results[0].labels():
-                st.session_state[f"rename_{curr}_{sp}"] = saved.get(sp, "")
+                # Sidebar assignment wins
+                new_renames[sp] = token_to_name[token]
+            elif sp in inline:
+                # Tab assignment used only when sidebar has no claim
+                new_renames[sp] = inline[sp]
+            # else: no assignment — omit (raw label will be used)
+        st.session_state.speakerRenames[fname] = new_renames
 
 
 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"])
-    print(f"[DEBUG enforceExclusivity] idx={changed_idx} tokens={changed_tokens}")
     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]
-        print(f"[DEBUG enforceExclusivity] entry[{idx}] {entry['name']}: {entry['speakers']} -> {new_speakers}")
         if new_speakers != entry["speakers"]:
             entry["speakers"] = new_speakers
             st.session_state.pop(_global_rename_key(idx), None)
-    print(f"[DEBUG enforceExclusivity] globalRenames after: {st.session_state.globalRenames}")
     applyGlobalRenames()
 
 
@@ -235,40 +211,22 @@ def removeGlobalRename(index):
 
 
 def apply_inline_rename(currFile, raw_sp, new_name):
-    """Write a single inline rename into both speakerRenames and globalRenames.
+    """Write a tab-originated rename into inlineRenames, then sync speakerRenames.
 
-    Keeps the sidebar global-rename list in sync so applyGlobalRenames()
-    won't overwrite the change on the next rerun.
+    inlineRenames is the sole record of tab renames. applyGlobalRenames() merges
+    inlineRenames with globalRenames every time it runs, so sidebar assignments
+    always win and tab assignments fill the rest.
     """
     new_name = new_name.strip()
-    token = f"{currFile}: {raw_sp}"
-
-    # Always remove this token from every existing entry first so it can't
-    # be claimed by more than one name at the same time.
-    # We delete the widget key (rather than overwriting it) to avoid the
-    # Streamlit "cannot modify after widget is instantiated" error — the
-    # render loop will reseed it from globalRenames data on the next rerun.
-    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)
 
+    inline = st.session_state.inlineRenames.setdefault(currFile, {})
     if new_name:
-        # Write into speakerRenames immediately
-        st.session_state.speakerRenames.setdefault(currFile, {})[raw_sp] = new_name
-        # Find an existing globalRenames entry for this name, or create one
-        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
-        idx = len(st.session_state.globalRenames)
-        st.session_state.globalRenames.append({"name": new_name, "speakers": [token]})
-        # Don't pre-set the widget key here — render loop will seed it
+        inline[raw_sp] = new_name
     else:
-        # Empty name — clear the rename for this speaker (token already removed above)
-        st.session_state.speakerRenames.setdefault(currFile, {}).pop(raw_sp, None)
+        inline.pop(raw_sp, None)
+
+    # Immediately reflect in speakerRenames (sidebar may override on next run)
+    applyGlobalRenames()
 
 
 # ---------------------------------------------------------------------------
@@ -332,6 +290,7 @@ def register_file(fname):
     while len(st.session_state.categorySelect) < len(st.session_state.categories):
         st.session_state.categorySelect.append([])
     st.session_state.speakerRenames.setdefault(fname, {})
+    st.session_state.inlineRenames.setdefault(fname, {})
     st.session_state.speakerClips.setdefault(fname, {})
     if fname not in st.session_state.file_names:
         st.session_state.file_names.append(fname)