Update state.py

state.py

@@ -5,7 +5,8 @@ Covers:
   - init_session_state()
   - Speaker rename helpers (get_display_name, apply_speaker_renames_to_df)
   - Category callbacks (addCategory, removeCategory, updateCategoryOptions)
-  - Global rename callbacks (addGlobalRename, removeGlobalRename, applyGlobalRenames)
+  - Global rename callbacks (addGlobalRename, removeGlobalRename, on_grename_change,
+    apply_inline_rename)
   - File-switch callback (updateMultiSelect)
   - analyze() — builds and caches all DataFrames for a single file
   - convert_df(), printV()
@@ -42,8 +43,8 @@ def init_session_state():
         "results":          {},   # {filename: (annotations, totalSeconds)}
         "speakerRenames":   {},   # {filename: {speaker: name}}
         "summaries":        {},   # {filename: {df2, df3, ...}}
-        "categories":       [],
-        "categorySelect":   {},   # {filename: [[], [], ...]}
+        "categories":       ["Instructor", "Students"],
+        "categorySelect":   [[], []],   # [[token, ...], ...]  one list per category, tokens = "fname: SPEAKER_##"; starts with 2 lists for Instructor/Students
         "removeCategory":   None,
         "resetResult":      False,
         "unusedSpeakers":   {},   # {filename: [speaker, ...]}
@@ -90,149 +91,194 @@ def convert_df(df):
 # ---------------------------------------------------------------------------
 
 def addCategory():
-    new = st.session_state.categoryInput
+    new = st.session_state.categoryInput.strip()
+    if not new:
+        return
     st.toast(f"Adding {new}")
-    st.session_state[f"multiselect_{new}"] = []
     st.session_state.categories.append(new)
+    st.session_state.categorySelect.append([])
+    st.session_state.pop(f"multiselect_{new}", None)
     st.session_state.categoryInput = ""
-    for fname in st.session_state.categorySelect:
-        st.session_state.categorySelect[fname].append([])
 
 
 def removeCategory(index):
     name = st.session_state.categories[index]
     st.toast(f"Removing {name}")
-    del st.session_state[f"multiselect_{name}"]
-    del st.session_state[f"remove_{name}"]
+    st.session_state.pop(f"multiselect_{name}", None)
     del st.session_state.categories[index]
-    for fname in st.session_state.categorySelect:
-        del st.session_state.categorySelect[fname][index]
+    del st.session_state.categorySelect[index]
 
 
-def updateCategoryOptions(fileName):
+def updateCategoryOptions():
+    """Store tokens ('fname: SPEAKER_##') in the global categorySelect lists."""
     if st.session_state.resetResult:
         return
-    currAnnotation, _ = st.session_state.results[fileName]
-    speakerNames = list(currAnnotation.labels())
-    saved_renames = st.session_state.speakerRenames.get(fileName, {})
-    display_to_raw = {saved_renames.get(sp, sp): sp for sp in speakerNames}
-    unusedSpeakers = copy.deepcopy(speakerNames)
+    # Rebuild unusedSpeakers for every analyzed file based on current token assignments
     for i, category in enumerate(st.session_state.categories):
-        display_choices = list(st.session_state[f"multiselect_{category}"])
-        raw_choices = [display_to_raw.get(d, d) for d in display_choices]
-        st.session_state.categorySelect[fileName][i] = raw_choices
-        for sp in raw_choices:
-            try:
-                unusedSpeakers.remove(sp)
-            except ValueError:
-                pass
-    st.session_state.unusedSpeakers[fileName] = unusedSpeakers
+        st.session_state.categorySelect[i] = list(
+            st.session_state[f"multiselect_{category}"]
+        )
+    # Recompute unusedSpeakers for all files
+    all_assigned_tokens = {
+        token
+        for tokens in st.session_state.categorySelect
+        for token in tokens
+    }
+    for fname, result in st.session_state.results.items():
+        if len(result) != 2:
+            continue
+        annotation, _ = result
+        unused = [
+            sp for sp in annotation.labels()
+            if f"{fname}: {sp}" not in all_assigned_tokens
+        ]
+        st.session_state.unusedSpeakers[fname] = unused
 
 
 # ---------------------------------------------------------------------------
 # Global rename callbacks
 # ---------------------------------------------------------------------------
 
+# ---------------------------------------------------------------------------
+# Global rename helpers
+# ---------------------------------------------------------------------------
+
 def _global_rename_key(index):
     return f"grename_speakers_{index}"
 
 
-def applyGlobalRenames():
-    """Re-write speakerRenames from globalRenames and refresh widget keys."""
-    for fname in st.session_state.speakerRenames:
-        st.session_state.speakerRenames[fname] = {}
-    for entry in st.session_state.globalRenames:
-        display_name = entry["name"]
-        for token in entry["speakers"]:
-            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] = display_name
-    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, "")
-
-
-def enforceGlobalRenameExclusivity(changed_idx):
-    """Ensure a token assigned to entry[changed_idx] is removed from all others.
-
-    Called by the sidebar multiselect on_change so that picking a speaker for
-    one name automatically unassigns it from any previously-holding name.
-    We pop (not overwrite) stale widget keys to avoid the Streamlit
-    "cannot modify after instantiation" error.
+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.
     """
-    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
-            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
+    for entry in st.session_state.globalRenames:
+        if entry["name"] == new_name:
+            st.toast(f"'{new_name}' already exists in the rename list")
+            st.session_state.globalRenameInput = ""
+            return
     st.toast(f"Adding rename '{new_name}'")
     st.session_state.globalRenames.append({"name": new_name, "speakers": []})
-    st.session_state[_global_rename_key(len(st.session_state.globalRenames) - 1)] = []
     st.session_state.globalRenameInput = ""
 
 
 def removeGlobalRename(index):
     entry = st.session_state.globalRenames[index]
     st.toast(f"Removing rename '{entry['name']}'")
+    # 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
     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.
-
-    Keeps the sidebar global-rename list in sync so applyGlobalRenames()
-    won't overwrite the change on the next rerun.
-    """
+    """Write a rename from the Rename Speaker tab into speakerRenames and globalRenames."""
     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)
 
     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
+        _write_rename(token, new_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
-        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
     else:
-        # Empty name — clear the rename for this speaker (token already removed above)
-        st.session_state.speakerRenames.setdefault(currFile, {}).pop(raw_sp, None)
+        _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, write name into speakerRenames.
+    - Removed tokens → revert speakerRenames for those tokens.
+
+    Spurious-callback guard: Streamlit sometimes re-fires this callback with an
+    empty widget value when available_tokens changes (e.g. another entry just
+    claimed a token, shrinking options). We detect this by checking whether the
+    widget value went to empty while the data model still has speakers — if ALL
+    of the previous speakers are still valid options for this entry we treat the
+    empty report as a Streamlit glitch and restore the widget key from the data
+    model instead of acting on it.
+    """
+    grkey = _global_rename_key(idx)
+    entry = st.session_state.globalRenames[idx]
+    name  = entry["name"]
+
+    prev     = list(entry["speakers"])   # current data-model state (ordered)
+    reported = list(st.session_state.get(grkey, []))
+
+    # Build the set of tokens that are legitimately available for this entry
+    # right now (not claimed by any OTHER entry).
+    other_claimed = {
+        t
+        for other_idx, other_entry in enumerate(st.session_state.globalRenames)
+        if other_idx != idx
+        for t in other_entry["speakers"]
+    }
+
+    # Spurious-empty guard: if the widget reports [] but the data model has
+    # tokens and every one of them is still a valid (unclaimed) option, this is
+    # a Streamlit re-fire artefact — restore the key and do nothing.
+    if not reported and prev:
+        all_still_valid = all(t not in other_claimed for t in prev)
+        if all_still_valid:
+            st.session_state[grkey] = prev
+            return
+
+    prev_set = set(prev)
+    new_set  = set(reported)
+    added    = new_set - prev_set
+    removed  = prev_set - new_set
+
+    # Write the new speakers list to the data model
+    kept = [t for t in prev if t in new_set]
+    entry["speakers"] = kept + [t for t in added]
+    st.session_state.pop(grkey, None)
+
+    # Enforce exclusivity and write renames for newly added tokens
+    for token in added:
+        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)
+                _write_rename(token, "")
+        _write_rename(token, name)
+
+    # Revert speakerRenames for tokens genuinely removed from this entry
+    for token in removed:
+        _write_rename(token, "")
 
 
 # ---------------------------------------------------------------------------
@@ -245,19 +291,12 @@ 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, {})
-    raw_to_display = {}
-    for sp in speakerNames:
-        saved = saved_renames.get(sp, "")
-        st.session_state[f"rename_{fileName}_{sp}"] = saved
-        raw_to_display[sp] = saved if saved else sp
-    for i, category in enumerate(st.session_state.categories):
-        raw_choices = st.session_state.categorySelect[fileName][i]
-        st.session_state[f"multiselect_{category}"] = [
-            raw_to_display.get(sp, sp) for sp in raw_choices
-        ]
+    # 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
+    for i in range(len(st.session_state.globalRenames)):
+        st.session_state.pop(_global_rename_key(i), None)
 
 
 # ---------------------------------------------------------------------------
@@ -294,9 +333,9 @@ def register_file(fname):
     st.session_state.results.setdefault(fname, [])
     st.session_state.summaries.setdefault(fname, {})
     st.session_state.unusedSpeakers.setdefault(fname, [])
-    st.session_state.categorySelect.setdefault(
-        fname, [[] for _ in st.session_state.categories]
-    )
+    # Ensure categorySelect has one list per category (global, not per-file)
+    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.speakerClips.setdefault(fname, {})
     if fname not in st.session_state.file_names:
@@ -437,7 +476,12 @@ def analyze(inFileName):
 
         currAnnotation, currTotalTime = st.session_state.results[inFileName]
         speakerNames      = currAnnotation.labels()
-        categorySelections = st.session_state.categorySelect[inFileName]
+        # categorySelect is global tokens ("fname: SPEAKER_##"); extract raw IDs for this file
+        prefix = inFileName + ": "
+        categorySelections = [
+            [token[len(prefix):] for token in tokens if token.startswith(prefix)]
+            for tokens in st.session_state.categorySelect
+        ]
         printV("Loaded results", 4)
 
         noVoice, oneVoice, multiVoice = su.calcSpeakingTypes(currAnnotation, currTotalTime)