Update app.py

app.py

@@ -39,19 +39,17 @@ def printV(message,verbosityLevel):
     if verbosity>=verbosityLevel:
         print(message)
         
-def get_display_name(speaker, fileIndex):
+def get_display_name(speaker, fileName):
     """Return the user-assigned display name for a speaker, or the original label."""
     renames = st.session_state.speakerRenames
-    if fileIndex < len(renames) and speaker in renames[fileIndex]:
-        return renames[fileIndex][speaker]
-    return speaker
+    return renames.get(fileName, {}).get(speaker, speaker)
 
-def apply_speaker_renames_to_df(df, fileIndex, column="task"):
+def apply_speaker_renames_to_df(df, fileName, column="task"):
     """Replace speaker_## labels in a DataFrame column with display names."""
     if column not in df.columns:
         return df
     df = df.copy()
-    df[column] = df[column].apply(lambda s: get_display_name(s, fileIndex))
+    df[column] = df[column].apply(lambda s: get_display_name(s, fileName))
     return df
     
 @st.cache_data
@@ -127,10 +125,7 @@ def generate_speaker_clips(annotations, waveform, sample_rate, file_index):
     """
     import io
 
-    # Extend speakerClips list to cover this file index
-    while len(st.session_state.speakerClips) <= file_index:
-        st.session_state.speakerClips.append({})
-
+    # file_index is now a filename string
     clips = {}
     for speaker in annotations.labels():
         speaker_segments = [
@@ -159,7 +154,7 @@ def generate_speaker_clips(annotations, waveform, sample_rate, file_index):
         clips[speaker] = buffer.read()
 
     st.session_state.speakerClips[file_index] = clips
-    print(f"Generated {len(clips)} speaker clips for file index {file_index}")
+    print(f"Generated {len(clips)} speaker clips for {file_index}")
 
 def addCategory():
     newCategory = st.session_state.categoryInput
@@ -167,8 +162,8 @@ def addCategory():
     st.session_state[f'multiselect_{newCategory}'] = []
     st.session_state.categories.append(newCategory)
     st.session_state.categoryInput = ''
-    for resultGroup in st.session_state.categorySelect:
-        resultGroup.append([])
+    for fname in st.session_state.categorySelect:
+        st.session_state.categorySelect[fname].append([])
 
 def removeCategory(index):
     categoryName = st.session_state.categories[index]
@@ -176,55 +171,43 @@ def removeCategory(index):
     del st.session_state[f'multiselect_{categoryName}']
     del st.session_state[f'remove_{categoryName}']
     del st.session_state.categories[index]
-    for resultGroup in st.session_state.categorySelect:
-        del resultGroup[index]
+    for fname in st.session_state.categorySelect:
+        del st.session_state.categorySelect[fname][index]
     
-def updateCategoryOptions(resultIndex):
+def updateCategoryOptions(fileName):
     if st.session_state.resetResult:
-        #st.info(f"Skipping update of {resultIndex}")
         return
-    #st.info(f"Updating result {resultIndex}")
-    #st.info(f"In update: {st.session_state.categorySelect}")
-    # Handle 
-    _, currAnnotation, _ = st.session_state.results[currFileIndex]
+    currAnnotation, _ = st.session_state.results[fileName]
     speakerNames = currAnnotation.labels()
-
-    # Handle speaker category sidebars
     unusedSpeakers = copy.deepcopy(speakerNames)
-    # Remove used speakers
     for i, category in enumerate(st.session_state['categories']):
         category_choices = copy.deepcopy(st.session_state[f'multiselect_{category}'])
-        st.session_state["categorySelect"][resultIndex][i] = category_choices
+        st.session_state["categorySelect"][fileName][i] = category_choices
         for sp in category_choices:
             try:
                 unusedSpeakers.remove(sp)
             except:
                 continue
-    st.session_state.unusedSpeakers[resultIndex] = unusedSpeakers
-    #st.info(f"After update: {st.session_state.categorySelect}")
+    st.session_state.unusedSpeakers[fileName] = unusedSpeakers
 
 def updateMultiSelect():
-    currFileIndex = st.session_state.file_names.index(st.session_state["select_currFile"])
+    fileName = st.session_state["select_currFile"]
     st.session_state.resetResult = True
     for i, category in enumerate(st.session_state['categories']):
-        st.session_state[f'multiselect_{category}'] = st.session_state['categorySelect'][currFileIndex][i]
+        st.session_state[f'multiselect_{category}'] = st.session_state['categorySelect'][fileName][i]
     
 def analyze(inFileName):
     try:
         print(f"Start analyzing {inFileName}")
         st.session_state.resetResult = False
-        currFileIndex = file_names.index(inFileName)
-        print(f"Found at index {currFileIndex}")
-        if len(st.session_state.results) > currFileIndex and len(st.session_state.summaries) > currFileIndex and len(st.session_state.results[currFileIndex]) > 0:
+        if inFileName in st.session_state.results and inFileName in st.session_state.summaries and len(st.session_state.results[inFileName]) > 0:
             
             printV(f'In if',4)
-            # Handle 
-            currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
+            currAnnotation, currTotalTime = st.session_state.results[inFileName]
             speakerNames = currAnnotation.labels()
             printV(f'Loaded results',4)
-            # Update other categories
-            unusedSpeakers = st.session_state.unusedSpeakers[currFileIndex]
-            categorySelections = st.session_state["categorySelect"][currFileIndex]
+            unusedSpeakers = st.session_state.unusedSpeakers[inFileName]
+            categorySelections = st.session_state["categorySelect"][inFileName]
             printV(f'Loaded speaker selections',4)
             noVoice, oneVoice, multiVoice = su.calcSpeakingTypes(currAnnotation,currTotalTime)
             sumNoVoice = su.sumTimes(noVoice)
@@ -241,7 +224,7 @@ def analyze(inFileName):
                 }
             )
             df3.name = "df3"
-            st.session_state.summaries[currFileIndex]["df3"] = df3
+            st.session_state.summaries[inFileName]["df3"] = df3
             printV(f'Set df3',4)
             
             # --- Build df4 ---
@@ -275,7 +258,7 @@ def analyze(inFileName):
             }
             df4 = pd.DataFrame(data=df4_dict)
             df4.name = "df4"
-            st.session_state.summaries[currFileIndex]["df4"] = df4
+            st.session_state.summaries[inFileName]["df4"] = df4
             printV(f'Set df4', 4)
 
             # --- Build df5 ---
@@ -331,20 +314,20 @@ def analyze(inFileName):
                   + [(t * 100) / summativeMultiSpeaker for t in multiTimeList],
             })
             df5.name = "df5"
-            st.session_state.summaries[currFileIndex]["df5"] = df5
+            st.session_state.summaries[inFileName]["df5"] = df5
             printV(f'Set df5', 4)
 
             # --- Build speakers_dataFrame, df2 ---
             speakers_dataFrame, speakers_times = su.annotationToDataFrame(currAnnotation)
-            st.session_state.summaries[currFileIndex]["speakers_dataFrame"] = speakers_dataFrame
-            st.session_state.summaries[currFileIndex]["speakers_times"] = speakers_times
+            st.session_state.summaries[inFileName]["speakers_dataFrame"] = speakers_dataFrame
+            st.session_state.summaries[inFileName]["speakers_times"] = speakers_times
 
             df2_dict = {
                 "values": [100 * t / currTotalTime for t in df4_dict["values"]],
                 "names": df4_dict["names"],
             }
             df2 = pd.DataFrame(df2_dict)
-            st.session_state.summaries[currFileIndex]["df2"] = df2
+            st.session_state.summaries[inFileName]["df2"] = df2
             printV(f'Set df2', 4)
     except Exception as e:
         import traceback
@@ -393,34 +376,32 @@ pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1")
 pipeline.to(device)#torch.device("cuda"))
 
 # Store results for viewing and further processing
-# Long-range usage
+# All per-file state is keyed by filename (str) so it survives upload order changes.
 if 'results' not in st.session_state:
-    st.session_state.results = []
+    st.session_state.results = {}        # {filename: (annotations, totalSeconds)}
 if 'speakerRenames' not in st.session_state:
-    st.session_state.speakerRenames = []
+    st.session_state.speakerRenames = {} # {filename: {speaker: name}}
 if 'summaries' not in st.session_state:
-    st.session_state.summaries = []
+    st.session_state.summaries = {}      # {filename: {df2, df3, ...}}
 if 'categories' not in st.session_state:
     st.session_state.categories = []
-    st.session_state.categorySelect = []
-# Single Use
+    st.session_state.categorySelect = {} # {filename: [[], [], ...]}
 if 'removeCategory' not in st.session_state:
     st.session_state.removeCategory = None
 if 'resetResult' not in st.session_state:
     st.session_state.resetResult = False
-# Specific to target file
 if 'unusedSpeakers' not in st.session_state:
-    st.session_state.unusedSpeakers = []
+    st.session_state.unusedSpeakers = {} # {filename: [speaker, ...]}
 if 'file_names' not in st.session_state:
     st.session_state.file_names = []
 if 'valid_files' not in st.session_state:
     st.session_state.valid_files = []
 if 'file_paths' not in st.session_state:
-    st.session_state.file_paths = []
+    st.session_state.file_paths = {}     # {filename: path}
 if 'showSummary' not in st.session_state:
     st.session_state.showSummary = 'No'
 if 'speakerClips' not in st.session_state:
-    st.session_state.speakerClips = []  # List of dicts: {speaker_label: wav_bytes} per file
+    st.session_state.speakerClips = {}   # {filename: {speaker: wav_bytes}}
     
 
     
@@ -447,127 +428,97 @@ temp_dir = tempfile.mkdtemp()
 
 if uploaded_file_paths is not None and len(uploaded_file_paths) > 0:
     print("Found file paths")
-    valid_files = []
-    file_paths = []
-    file_names = []
     for uploaded_file in uploaded_file_paths:
         if not uploaded_file.name.lower().endswith(supported_file_types):
             st.error('File must be of type: {}'.format(supported_file_types))
-            uploaded_file = None
         else:
-            print(f"Valid file: {uploaded_file.name}")
-            if uploaded_file not in valid_files:
-                path = os.path.join(temp_dir, uploaded_file.name)
-                with open(path, "wb") as f:
-                    f.write(uploaded_file.getvalue())
-                valid_files.append(uploaded_file)
-                file_paths.append(path)
-    # Save valid file names
-    if len(valid_files) > 0:
-        file_names = [f.name for f in valid_files]
-
-    # --- Reconcile per-file state lists against the new file set ---
-    # For each new file, carry over existing state if the filename matches a
-    # previously analyzed file, otherwise insert a fresh empty slot.
-    prev_names = st.session_state.file_names
-    def _carry(old_list, empty_val_fn):
-        new_list = []
-        for name in file_names:
-            if name in prev_names:
-                idx = prev_names.index(name)
-                new_list.append(old_list[idx] if idx < len(old_list) else empty_val_fn())
-            else:
-                new_list.append(empty_val_fn())
-        return new_list
-
-    st.session_state.results       = _carry(st.session_state.results,        lambda: [])
-    st.session_state.summaries     = _carry(st.session_state.summaries,       lambda: [])
-    st.session_state.unusedSpeakers= _carry(st.session_state.unusedSpeakers,  lambda: [])
-    st.session_state.categorySelect= _carry(st.session_state.categorySelect,
-                                            lambda: [[] for _ in st.session_state.categories])
-    st.session_state.speakerRenames= _carry(st.session_state.speakerRenames,  lambda: {})
-    st.session_state.speakerClips  = _carry(st.session_state.speakerClips,    lambda: {})
-
-    st.session_state.file_names = file_names
+            fname = uploaded_file.name
+            print(f"Valid file: {fname}")
+            # Write to disk (always refresh so file bytes are current)
+            path = os.path.join(temp_dir, fname)
+            with open(path, "wb") as f:
+                f.write(uploaded_file.getvalue())
+            # Add to master lists only if not already tracked
+            if fname not in st.session_state.file_names:
+                st.session_state.file_names.append(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])
+                st.session_state.speakerRenames.setdefault(fname, {})
+                st.session_state.speakerClips.setdefault(fname, {})
+            st.session_state.file_paths[fname] = path
+    # Rebuild valid_files / file_paths lists from tracked state
+    valid_files = [f for f in st.session_state.file_names]
+    file_paths = [st.session_state.file_paths[f] for f in valid_files]
+    file_names = valid_files
     st.session_state.valid_files = valid_files
-    st.session_state.file_paths = file_paths
+    st.session_state.file_paths = {f: st.session_state.file_paths[f] for f in valid_files}
 
 file_names = st.session_state.file_names
-    
+file_paths_dict = st.session_state.file_paths  # dict {fname: path}
+
 if len(file_names) == 0:
     st.text("Upload file(s) to enable analysis")
 else:
     if st.button("Analyze All New Audio",key=f"button_all"):
-        if len(valid_files) == 0:
+        if len(file_names) == 0:
             st.error('Upload file(s) first!')
         else:
             print("Start analyzing")
             start_time = time.time()
-            totalFiles = len(valid_files)
-            for i in range(totalFiles):
-                if len(st.session_state.results) > i and len(st.session_state.results[i]) > 0:
+            totalFiles = len(file_names)
+            for i, fname in enumerate(file_names):
+                fpath = file_paths_dict.get(fname, "")
+                if st.session_state.results.get(fname):
                     continue
-                # Text files use sample data
-                if file_paths[i].lower().endswith('.txt'):
+                if fpath.lower().endswith('.txt'):
                     with st.spinner(text=f'Loading Demo File {i+1} of {totalFiles}'):
-                        # RTTM load as filler
-                        speakerList, annotations = su.loadAudioTXT(file_paths[i])
+                        speakerList, annotations = su.loadAudioTXT(fpath)
                         printV(annotations,4)
-                        # Approximate total seconds
                         totalSeconds = 0
                         for segment in annotations.itersegments():
                             if segment.end > totalSeconds:
                                 totalSeconds = segment.end
-                        st.session_state.results[i] = (annotations, totalSeconds)
-                        st.session_state.summaries[i] = {}
-                        speakerNames = annotations.labels()
-                        st.session_state.unusedSpeakers[i] = speakerNames
-                elif file_paths[i].lower().endswith('.rttm'):
+                        st.session_state.results[fname] = (annotations, totalSeconds)
+                        st.session_state.summaries[fname] = {}
+                        st.session_state.unusedSpeakers[fname] = list(annotations.labels())
+                elif fpath.lower().endswith('.rttm'):
                     with st.spinner(text=f'Loading File {i+1} of {totalFiles}'):
-                        # RTTM load as filler
-                        speakerList, annotations = su.loadAudioRTTM(file_paths[i])
+                        speakerList, annotations = su.loadAudioRTTM(fpath)
                         printV(annotations,4)
-                        # Approximate total seconds
                         totalSeconds = 0
                         for segment in annotations.itersegments():
                             if segment.end > totalSeconds:
                                 totalSeconds = segment.end
-                        st.session_state.results[i] = (annotations, totalSeconds)
-                        st.session_state.summaries[i] = {}
-                        speakerNames = annotations.labels()
-                        st.session_state.unusedSpeakers[i] = speakerNames
-                elif file_paths[i].lower().endswith('.csv'):
+                        st.session_state.results[fname] = (annotations, totalSeconds)
+                        st.session_state.summaries[fname] = {}
+                        st.session_state.unusedSpeakers[fname] = list(annotations.labels())
+                elif fpath.lower().endswith('.csv'):
                     with st.spinner(text=f'Loading File {i+1} of {totalFiles}'):
-                        # RTTM load as filler
-                        speakerList, annotations = su.loadAudioCSV(file_paths[i])
+                        speakerList, annotations = su.loadAudioCSV(fpath)
                         printV(annotations,4)
-                        # Approximate total seconds
                         totalSeconds = 0
                         for segment in annotations.itersegments():
                             if segment.end > totalSeconds:
                                 totalSeconds = segment.end
-                        st.session_state.results[i] = (annotations, totalSeconds)
-                        st.session_state.summaries[i] = {}
-                        speakerNames = annotations.labels()
-                        st.session_state.unusedSpeakers[i] = speakerNames
+                        st.session_state.results[fname] = (annotations, totalSeconds)
+                        st.session_state.summaries[fname] = {}
+                        st.session_state.unusedSpeakers[fname] = list(annotations.labels())
                 else:
                     with st.spinner(text=f'Processing File {i+1} of {totalFiles}'):
-                        annotations, totalSeconds, waveform, sample_rate = processFile(file_paths[i])
-                        print(f"Finished processing {file_paths[i]}")
-                        st.session_state.results[i] = (annotations, totalSeconds)
-                        print("Results saved")
-                        st.session_state.summaries[i] = {}
-                        print("Summaries saved")
-                        speakerNames = annotations.labels()
-                        st.session_state.unusedSpeakers[i] = speakerNames 
-                        print("Speakers saved")
+                        annotations, totalSeconds, waveform, sample_rate = processFile(fpath)
+                        print(f"Finished processing {fpath}")
+                        st.session_state.results[fname] = (annotations, totalSeconds)
+                        st.session_state.summaries[fname] = {}
+                        st.session_state.unusedSpeakers[fname] = list(annotations.labels())
                     with st.spinner(text=f'Generating speaker clips for File {i+1} of {totalFiles}'):
-                        generate_speaker_clips(annotations, waveform, sample_rate, i)
-                        del waveform  # free memory after clipping
-                        print(f"Speaker clips generated for {file_paths[i]}")
+                        generate_speaker_clips(annotations, waveform, sample_rate, fname)
+                        del waveform
+                        print(f"Speaker clips generated for {fpath}")
                 with st.spinner(text=f'Analyzing File {i+1} of {totalFiles}'):
-                    analyze(file_names[i])
-                    print(f"Finished analyzing {file_paths[i]}")
+                    analyze(fname)
+                    print(f"Finished analyzing {fpath}")
             print(f"Took {time.time() - start_time} seconds to analyze {totalFiles} files!")
             st.success(f"Took {time.time() - start_time} seconds to analyze {totalFiles} files!")
 
@@ -579,80 +530,58 @@ class FakeUpload:
 demoPath = "sample.rttm"
 isDemo = False
 if st.sidebar.button("Load Demo Example"):
-    sampleUpload = FakeUpload(demoPath)
-    valid_files=[sampleUpload]
-    file_paths=[sampleUpload.path]
-    file_names=[sampleUpload.name]
-    st.session_state.valid_files = valid_files
-    st.session_state.file_paths = file_paths
+    demoName = demoPath.split('/')[-1]
     start_time = time.time()
-    st.session_state.file_names = file_names
-    # Save valid file names
-    if len(valid_files) > 0:
-        file_names = [f.name for f in valid_files]
-    while (len(st.session_state.results) < len(valid_files)):
-        st.session_state.results.append([])
-    while (len(st.session_state.summaries) < len(valid_files)):
-        st.session_state.summaries.append([])
-    while (len(st.session_state.unusedSpeakers) < len(valid_files)):
-        st.session_state.unusedSpeakers.append([])
-    while (len(st.session_state.categorySelect) < len(valid_files)):
-        tempCategories = [[] for cat in st.session_state.categories]
-        st.session_state.categorySelect.append(tempCategories)
-    while (len(st.session_state.summaries) < len(valid_files)):
-        st.session_state.summaries.append([])
-    while (len(st.session_state.speakerRenames) < len(valid_files)):
-        st.session_state.speakerRenames.append({})
-    while (len(st.session_state.speakerClips) < len(valid_files)):
-        st.session_state.speakerClips.append({})
-        
+    if demoName not in st.session_state.file_names:
+        st.session_state.file_names.append(demoName)
+    st.session_state.file_paths[demoName] = demoPath
+    st.session_state.results.setdefault(demoName, [])
+    st.session_state.summaries.setdefault(demoName, {})
+    st.session_state.unusedSpeakers.setdefault(demoName, [])
+    st.session_state.categorySelect.setdefault(demoName, [[] for _ in st.session_state.categories])
+    st.session_state.speakerRenames.setdefault(demoName, {})
+    st.session_state.speakerClips.setdefault(demoName, {})
+    file_names = st.session_state.file_names
+
     with st.spinner(text=f'Loading Demo Sample'):
-        # RTTM load as filler
-        speakerList, annotations = su.loadAudioRTTM(file_paths[0])
-        # Approximate total seconds
+        speakerList, annotations = su.loadAudioRTTM(demoPath)
         totalSeconds = 0
         for segment in annotations.itersegments():
             if segment.end > totalSeconds:
                 totalSeconds = segment.end
-        st.session_state.results = [(annotations, totalSeconds)]
-        st.session_state.summaries = [{}]
-        while len(st.session_state.speakerRenames) < 1:
-            st.session_state.speakerRenames.append({})
-        speakerNames = annotations.labels()
-        st.session_state.unusedSpeakers = [speakerNames]
+        st.session_state.results[demoName] = (annotations, totalSeconds)
+        st.session_state.summaries[demoName] = {}
+        st.session_state.unusedSpeakers[demoName] = list(annotations.labels())
         with st.spinner(text=f'Analyzing Demo Data'):
-                    analyze(file_names[0])
+            analyze(demoName)
     st.success(f"Took {time.time() - start_time} seconds to analyze the demo file!")
-    st.session_state.select_currFile=file_names[0]
+    st.session_state.select_currFile = demoName
     isDemo = True
             
-currFile = st.sidebar.selectbox('Current File', file_names,on_change=updateMultiSelect,key="select_currFile")
+currFile = st.sidebar.selectbox('Current File', file_names, on_change=updateMultiSelect, key="select_currFile")
 
 if isDemo:
-    currFile=file_names[0]
+    currFile = file_names[0]
     isDemo = False
-    
-if currFile is None and len(st.session_state.results) > 0 and len(st.session_state.results[0]) > 0:
+
+if currFile is None and st.session_state.results:
     st.write("Select a file to view from the sidebar")
 try:
     st.session_state.resetResult = False
-    currFileIndex = file_names.index(currFile)
     currPlainName = currFile.split('.')[0]
-    if len(st.session_state.results) > currFileIndex and len(st.session_state.summaries) > currFileIndex and len(st.session_state.results[currFileIndex]) > 0:
+    if currFile in st.session_state.results and currFile in st.session_state.summaries and len(st.session_state.results[currFile]) > 0:
         st.header(f"Analysis of file {currFile}")
         graphNames = ["Data","Voice Categories","Speaker Percentage","Speakers with Categories","Treemap","Timeline","Time Spoken"]
         dataTab, pie1, pie2, sunburst1, treemap1, timeline, bar1 = st.tabs(graphNames)
-        # Handle 
-        currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
+        currAnnotation, currTotalTime = st.session_state.results[currFile]
         speakerNames = currAnnotation.labels()
-    
-        speakers_dataFrame = st.session_state.summaries[currFileIndex]["speakers_dataFrame"]
+
+        speakers_dataFrame = st.session_state.summaries[currFile]["speakers_dataFrame"]
         currDF, _ = su.annotationToSimpleDataFrame(currAnnotation)
-        speakers_times = st.session_state.summaries[currFileIndex]["speakers_times"]
-        
-        # Update other categories
-        unusedSpeakers = st.session_state.unusedSpeakers[currFileIndex]
-        categorySelections = st.session_state["categorySelect"][currFileIndex]
+        speakers_times = st.session_state.summaries[currFile]["speakers_times"]
+
+        unusedSpeakers = st.session_state.unusedSpeakers[currFile]
+        categorySelections = st.session_state["categorySelect"][currFile]
         for i,category in enumerate(st.session_state.categories):
             speakerSet = categorySelections[i]
             st.sidebar.multiselect(category,
@@ -660,7 +589,7 @@ try:
                                     default=speakerSet,
                                     key=f"multiselect_{category}",
                                     on_change=updateCategoryOptions,
-                                    args=(currFileIndex,))
+                                    args=(currFile,))
             st.sidebar.button(f"Remove {category}",key=f"remove_{category}",on_click=removeCategory,args=(i,))
 
 
@@ -672,38 +601,34 @@ try:
         st.sidebar.caption("Replace SPEAKER_## labels with real names.")
 
         # --- Speaker clip preview ---
-        file_clips = (
-            st.session_state.speakerClips[currFileIndex]
-            if currFileIndex < len(st.session_state.speakerClips)
-            else {}
-        )
+        file_clips = st.session_state.speakerClips.get(currFile, {})
         if file_clips:
             st.sidebar.caption(
                 "Listen to each speaker's longest clip (up to 5 s) to help identify them."
             )
 
-        current_renames = st.session_state.speakerRenames[currFileIndex]
+        current_renames = st.session_state.speakerRenames[currFile]
         for sp in speakerNames:
-            widget_key = f"rename_{currFileIndex}_{sp}"
-            # Seed the widget state once from speakerRenames (e.g. after a file switch).
-            # After that, never pass value= so Streamlit never overwrites what the user typed.
+            widget_key = f"rename_{currFile}_{sp}"
+            # Seed the widget state once; never pass value= so reruns don't overwrite it
             if widget_key not in st.session_state:
                 st.session_state[widget_key] = current_renames.get(sp, "")
-            # Use live widget value for the display label so it updates immediately
             live_name = st.session_state[widget_key].strip()
             display_label = live_name if live_name else sp
             st.sidebar.markdown(f"**{display_label}**")
             if sp in file_clips:
                 st.sidebar.audio(file_clips[sp], format="audio/wav")
+            # Label is always the fixed original sp so Streamlit never recreates the widget
             new_name = st.sidebar.text_input(
-                f"Rename {display_label}",
+                sp,
                 placeholder="e.g. John",
-                key=widget_key
+                key=widget_key,
+                label_visibility="collapsed"
             )
             if new_name.strip():
-                st.session_state.speakerRenames[currFileIndex][sp] = new_name.strip()
-            elif sp in st.session_state.speakerRenames[currFileIndex]:
-                del st.session_state.speakerRenames[currFileIndex][sp]
+                st.session_state.speakerRenames[currFile][sp] = new_name.strip()
+            elif sp in st.session_state.speakerRenames[currFile]:
+                del st.session_state.speakerRenames[currFile][sp]
 
         catTypeColors = su.colorsCSS(3)
         allColors = su.colorsCSS(len(speakerNames)+len(st.session_state.categories))
@@ -730,10 +655,10 @@ try:
             }
         df4 = pd.DataFrame(data=df4_dict)
         df4.name = "df4"
-        st.session_state.summaries[currFileIndex]["df4"] = df4
+        st.session_state.summaries[currFile]["df4"] = df4
         
         with dataTab:
-            displayDF = apply_speaker_renames_to_df(currDF, currFileIndex, column="Resource")
+            displayDF = apply_speaker_renames_to_df(currDF, currFile, column="Resource")
             csv = convert_df(displayDF)
             
             st.download_button(
@@ -747,7 +672,7 @@ try:
             st.dataframe(displayDF)
         with pie1:
             printV("In Pie1",4)
-            df3 = st.session_state.summaries[currFileIndex]["df3"]
+            df3 = st.session_state.summaries[currFile]["df3"]
             fig1 = go.Figure()
             fig1.update_layout(
                 title_text="Percentage of each Voice Category",
@@ -796,14 +721,14 @@ try:
 
         with pie2:
             printV("In Pie2",4)
-            df4 = st.session_state.summaries[currFileIndex]["df4"].copy()
+            df4 = st.session_state.summaries[currFile]["df4"].copy()
         
             # Some speakers may be missing, so fix colors
             figColors = []
             for n in df4["names"]:
                 if n in speakerNames:
                     figColors.append(speakerColors[speakerNames.index(n)])
-            df4["names"] = df4["names"].apply(lambda s: get_display_name(s, currFileIndex))
+            df4["names"] = df4["names"].apply(lambda s: get_display_name(s, currFile))
             fig2 = go.Figure()
             fig2.update_layout(
                 title_text="Percentage of Speakers and Custom Categories",
@@ -845,9 +770,9 @@ try:
                         )
 
         with sunburst1:
-            df5 = st.session_state.summaries[currFileIndex]["df5"].copy()
-            df5["labels"] = df5["labels"].apply(lambda s: get_display_name(s, currFileIndex))
-            df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name(s, currFileIndex))
+            df5 = st.session_state.summaries[currFile]["df5"].copy()
+            df5["labels"] = df5["labels"].apply(lambda s: get_display_name(s, currFile))
+            df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name(s, currFile))
             fig3_1 = px.sunburst(df5,
                                 branchvalues = 'total',
                                 names = "labels",
@@ -903,9 +828,9 @@ try:
                         )
     
         with treemap1:
-            df5 = st.session_state.summaries[currFileIndex]["df5"].copy()
-            df5["labels"] = df5["labels"].apply(lambda s: get_display_name(s, currFileIndex))
-            df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name(s, currFileIndex))
+            df5 = st.session_state.summaries[currFile]["df5"].copy()
+            df5["labels"] = df5["labels"].apply(lambda s: get_display_name(s, currFile))
+            df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name(s, currFile))
             fig3 = px.treemap(df5,
                             branchvalues = "total",
                             names = "labels",
@@ -965,7 +890,7 @@ try:
 
         with timeline:
             timeline_df = speakers_dataFrame.copy()
-            timeline_df["Resource"] = timeline_df["Resource"].apply(lambda s: get_display_name(s, currFileIndex))
+            timeline_df["Resource"] = timeline_df["Resource"].apply(lambda s: get_display_name(s, currFile))
             base = dt.datetime.combine(dt.date.today(), dt.time.min)
             def to_audio_datetime(s):
                 # If already a datetime/Timestamp, extract seconds since midnight of that date
@@ -1034,8 +959,8 @@ try:
                         )
     
         with bar1:
-            df2 = st.session_state.summaries[currFileIndex]["df2"].copy()
-            df2["names"] = df2["names"].apply(lambda s: get_display_name(s, currFileIndex))
+            df2 = st.session_state.summaries[currFile]["df2"].copy()
+            df2["names"] = df2["names"].apply(lambda s: get_display_name(s, currFile))
             fig2_la = px.bar(df2, x="values", y="names", color="names", orientation='h',
                             custom_data=["names","values"],title="Time Spoken by each Speaker",
                             color_discrete_sequence=catColors+speakerColors)
@@ -1094,36 +1019,28 @@ if len(st.session_state.results) > 0:
         st.header("Multi-file Summary Data")
         with st.spinner(text='Processing summary results...'):
             fileNames = st.session_state.file_names
-            results = []
-            indices = []
-            for i, resultTuple in enumerate(st.session_state.results):
-                if len(resultTuple) == 2:
-                    results.append(resultTuple)
-                    indices.append(i)
-            if len(indices) > 1:
-                
-                df6_dict = {
-                    "files":fileNames,
-                }
+            validNames = [fn for fn in fileNames if fn in st.session_state.results and len(st.session_state.results[fn]) == 2]
+            if len(validNames) > 1:
+
+                df6_dict = {"files": validNames}
                 allCategories = copy.deepcopy(st.session_state.categories)
-                for i in indices:
-                    currAnnotation, currTotalTime = st.session_state.results[i]
-                    categorySelections = st.session_state["categorySelect"][i]
-                    catSummary,extraCats = su.calcCategories(currAnnotation,categorySelections)
-                    st.session_state.summaries[i]["categories"] = (catSummary,extraCats)
+                for fn in validNames:
+                    currAnnotation, currTotalTime = st.session_state.results[fn]
+                    categorySelections = st.session_state["categorySelect"][fn]
+                    catSummary, extraCats = su.calcCategories(currAnnotation, categorySelections)
+                    st.session_state.summaries[fn]["categories"] = (catSummary, extraCats)
                     for extra in extraCats:
                         df6_dict[extra] = []
                         if extra not in allCategories:
                             allCategories.append(extra)
-    
-            
+
                 for category in st.session_state.categories:
                     df6_dict[category] = []
-                for i in indices:
-                    summary, extras = st.session_state.summaries[i]["categories"]
+                for fn in validNames:
+                    summary, extras = st.session_state.summaries[fn]["categories"]
                     theseCategories = st.session_state.categories + extras
                     for j, timeSlots in enumerate(summary):
-                        df6_dict[theseCategories[j]].append(sum([t.duration for _,t in timeSlots])/st.session_state.results[i][1])
+                        df6_dict[theseCategories[j]].append(sum([t.duration for _,t in timeSlots])/st.session_state.results[fn][1])
                     for category in allCategories:
                         if category not in theseCategories:
                             df6_dict[category].append(0)
@@ -1138,8 +1055,8 @@ if len(st.session_state.results) > 0:
                 }
                 for category in voiceNames:
                     df7_dict[category] = []
-                for resultID,summary in enumerate(st.session_state.summaries):
-                    partialDf = summary["df5"]
+                for fn in validNames:
+                    partialDf = st.session_state.summaries[fn]["df5"]
                     for i in range(len(voiceNames)):
                         df7_dict[voiceNames[i]].append(partialDf["percentiles"][i])
                 df7 = pd.DataFrame(df7_dict)