Updated Analysis and Charts

app.py

@@ -23,50 +23,7 @@ from pyannote.core import Annotation, Segment, Timeline
 from df.enhance import enhance, init_df
 import datetime as dt
 
-torch.classes.__path__ = [os.path.join(torch.__path__[0], torch.classes.__file__)]
-
-PARQUET_DATASET_DIR = Path("parquet_dataset")
-PARQUET_DATASET_DIR.mkdir(parents=True,exist_ok=True)
-
-sample_data = [f"CHEM1402_gt/24F_CHEM1402_Night_Class_Week_{i}_gt.rttm" for i in range(1,11)]
 
-
-scheduler = ps.ParquetScheduler(repo_id="Sonogram/SampleDataset")
-
-secondDifference = 5
-gainWindow = 4
-minimumGain = -45
-maximumGain = -5
-attenLimDB = 3
-
-isGPU = False
-
-try:
-    raise(RuntimeError("Not an error"))
-    #device = xm.xla_device()
-    print("TPU is available.")
-    isGPU = True
-except RuntimeError as e:
-    print(f"TPU is not available: {e}")
-    # Fallback to CPU or other devices if needed
-    isGPU = torch.cuda.is_available()
-    device = torch.device("cuda" if isGPU else "cpu")
-    print(f"Using {device} instead.")
-#device = xm.xla_device()
-
-
-# Instantiate and prepare model for training.
-dfModel, dfState, _ = init_df(model_base_dir="DeepFilterNet3")
-dfModel.to(device)#torch.device("cuda"))
-pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1")
-pipeline.to(device)#torch.device("cuda"))
-
-# Store results for viewing and further processing
-if 'results' not in st.session_state:
-    st.session_state.results = []
-if 'summaries' not in st.session_state:
-    st.session_state.summaries = []
-    
 def save_data(
     config_dict: Dict[str,str], audio_paths: List[str], userid: str,
     ) -> None:
@@ -109,136 +66,234 @@ def processFile(filePath):
     waveform_gain_adjusted = su.equalizeVolume()(waveformEnhanced,sampleRate,gainWindow,minimumGain,maximumGain)
     print("Audio Equalized")
     print("Detecting speakers")
-    time.sleep(10)
     annotations = pipeline({"waveform": waveformEnhanced, "sample_rate": sampleRate})
     print("Speakers Detected")
     speakerList = su.annotationToSpeakerList(annotations)
     return (speakerList, annotations, int(waveformEnhanced.shape[-1]/sampleRate))
-    
-def removeOverlap(timeSegment,overlap):
-    times = []
-    if timeSegment.start < overlap.start:
-        times.append(Segment(timeSegment.start,min(overlap.start,timeSegment.end)))
-    if timeSegment.end > overlap.end:
-        times.append(Segment(max(timeSegment.start,overlap.end),timeSegment.end))
-    return times
-
-def checkForOverlap(time1, time2):
-    overlap = time1 & time2
-    if overlap:
-        return overlap
-    else:
-        return None
-    
 
-def calcCategories(annotation,maxTime):
-    noVoice = [Segment(0,maxTime)]
-    oneVoice = []
-    multiVoice = []
-    # TBD Clean this up!!!
-    rawData = {}
-    for speakerName in annotation.labels():
-        if speakerName not in rawData.keys():
-            rawData[speakerName] = []
-        for segmentItem in annotation.label_support(speakerName):
-            rawData[speakerName].append(segmentItem)
-    for speaker in rawData.keys():
-        timesToProcess = []
-        for timeSlot in rawData[speaker]:
-            timesToProcess.append((speaker,timeSlot))
-        while len(timesToProcess) > 0:
-            currID, currTime = timesToProcess[0]
-            timesToProcess.remove(timesToProcess[0])
-            resetCheck = False
-            # Check in multi
-            for compareID,timeSlot in multiVoice:
-                overlapTime = checkForOverlap(currTime,timeSlot)
-                if overlapTime is None:
-                    continue
-                else:
-                    compareID.append(currID)
-                    newTimes = removeOverlap(currTime,timeSlot)#+removeOverlap(timeSlot,currTime)
-                    for i in range(len(newTimes)):
-                        newTimes[i] = (currID,newTimes[i])
-                    timesToProcess += newTimes
-                    resetCheck = True
-                    break
-            if resetCheck:
+def addCategory():
+    newCategory = st.session_state.categoryInput
+    st.toast(f"Adding {newCategory}")
+    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([])
+
+def removeCategory(index):
+    categoryName = st.session_state.categories[index]
+    st.toast(f"Removing {categoryName}")
+    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]
+    
+def updateCategoryOptions(resultIndex):
+    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 
+    currResults = st.session_state.results[resultIndex][1]
+    speakerNames = [sp for sp in currResults["speakers"].keys()]
+
+    # 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
+        for sp in category_choices:
+            try:
+                unusedSpeakers.remove(sp)
+            except:
                 continue
-            # Check in one voice
-            for timeSlot in oneVoice:
-                tID = timeSlot[0]
-                tTime = timeSlot[1]
-                overlapTime = checkForOverlap(currTime,tTime)
-                if overlapTime is None:
+    st.session_state.unusedSpeakers[resultIndex] = unusedSpeakers
+    #st.info(f"After update: {st.session_state.categorySelect}")
+
+def updateMultiSelect():
+    currFileIndex = file_names.index(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]
+    
+def analyze(inFileName):
+    try:
+        st.session_state.resetResult = False
+        currFileIndex = file_names.index(inFileName)
+        if len(st.session_state.results) > currFileIndex and len(st.session_state.summaries) > currFileIndex and len(st.session_state.results[currFileIndex]) > 0:
+            # Handle 
+            currSpeakerList, currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
+            speakerNames = currAnnotation.labels()
+    
+            # Update other categories
+            unusedSpeakers = st.session_state.unusedSpeakers[currFileIndex]
+            categorySelections = st.session_state["categorySelect"][currFileIndex]
+            
+            noVoice, oneVoice, multiVoice = su.calcSpeakingTypes(currAnnotation,currTotalTime)
+            noVoice.sort()
+            oneVoice.sort()
+            multiVoice.sort()
+            
+            df3 = pd.DataFrame(
+                {
+                    "values": [sumTimes(noVoice),
+                                sumTimes([n for _,n in oneVoice]),
+                                sumTimes([n for _,n in multiVoice])],
+                    "names": ["No Voice","One Voice","Multi Voice"],
+                }
+            )
+            df3.name = "df3"
+            st.session_state.summaries[currFileIndex]["df3"] = df3
+            
+            canRemoveMaybe = '''df4_dict = {}
+            nameList = st.session_state.categories
+            extraNames = []
+            valueList = [0 for i in range(len(nameList))]
+            extraValues = []
+            
+            for sp in currResults["speakers"].keys():
+                foundSp = False
+                for i, categoryName in enumerate(nameList):
+                    if sp in categorySelections[i]:
+                        #st.info(categoryName)
+                        valueList[i] += sumTimes(currResults["speakers"][sp])
+                        foundSp = True
+                        break
+                if foundSp:
                     continue
                 else:
-                    oneVoice.remove(timeSlot)
-                    # Add back non overlap
-                    newTimes = removeOverlap(tTime,currTime)
-                    for i in range(len(newTimes)):
-                        newTimes[i] = (tID,newTimes[i])
-                    oneVoice += newTimes
-                    # Add overlap time to multivoice
-                    multiVoice.append(([tID,currID],overlapTime))
-                    # Add new times back to process
-                    newTimes = removeOverlap(currTime,tTime)
-                    for i in range(len(newTimes)):
-                        newTimes[i] = (currID,newTimes[i])
-                    timesToProcess += newTimes
-                    resetCheck = True
-                    break
-            if resetCheck:
-                continue
-            # Add to one voice
-            oneVoice.append((currID,currTime))
-    for _,timeSlot in multiVoice:
-        copyOfNo = copy.deepcopy(noVoice)
-        for emptySlot in noVoice:
-            if checkForOverlap(timeSlot,emptySlot) is None:
-                continue
-            else:
-                copyOfNo.remove(emptySlot)
-                copyOfNo += removeOverlap(emptySlot,timeSlot)
-        noVoice = copyOfNo
-    for _,timeSlot in oneVoice:
-        copyOfNo = copy.deepcopy(noVoice)
-        for emptySlot in noVoice:
-            if checkForOverlap(timeSlot,emptySlot) is None:
-                continue
-            else:
-                copyOfNo.remove(emptySlot)
-                copyOfNo += removeOverlap(emptySlot,timeSlot)
-        noVoice = copyOfNo
-    return noVoice, oneVoice, multiVoice, rawData 
-
-def sumTimes(timeList):
-    totalTime = 0
-    for timeSlot in timeList:
-        totalTime += timeSlot.duration
-    return totalTime
+                    extraNames.append(sp)
+                    extraValues.append(sumTimes(currResults["speakers"][sp]))
+            df4_dict = {
+                    "values": valueList+extraValues,
+                    "names": nameList+extraNames,
+                }
+            df4 = pd.DataFrame(data=df4_dict)
+            df4.name = "df4"
+            st.session_state.summaries[currFileIndex]["df4"] = df4'''
+            
+            speakerList,timeList = sumTimesPerSpeaker(oneVoice)
+            multiSpeakerList, multiTimeList = sumMultiTimesPerSpeaker(multiVoice)
+            summativeMultiSpeaker = sum(multiTimeList)
+            sumNoVoice = sumTimes(noVoice)
+            sumOneVoice = sumTimes([n for _,n in oneVoice])
+            sumMultiVoice = sumTimes([n for _,n in multiVoice])
+            basePercentiles = [sumNoVoice/currTotalTime,
+                                 sumOneVoice/currTotalTime,
+                                 sumMultiVoice/currTotalTime
+                                ]
+            df5 = pd.DataFrame(
+                {
+                    "ids" : ["NV","OV","MV"]+[f"OV_{i}" for i in range(len(speakerList))]
+                                +[f"MV_{i}" for i in range(len(multiSpeakerList))],
+                    "labels" : ["No Voice","One Voice","Multi Voice"] + speakerList + multiSpeakerList,
+                    "parents" : ["","",""]+["OV" for i in range(len(speakerList))]
+                                +["MV" for i in range(len(multiSpeakerList))],
+                    "parentNames" : ["Total","Total","Total"]+["One Voice" for i in range(len(speakerList))]
+                                +["Multi Voice" for i in range(len(multiSpeakerList))],
+                    "values" : [sumNoVoice,
+                                sumOneVoice,
+                                sumMultiVoice,
+                                ] + timeList + multiTimeList,
+                    "valueStrings" : [timeToString(sumNoVoice),
+                                timeToString(sumOneVoice),
+                                timeToString(sumMultiVoice),
+                                ] + timeToString(timeList) + timeToString(multiTimeList),
+                    "percentiles" : [basePercentiles[0]*100,
+                                     basePercentiles[1]*100,
+                                     basePercentiles[2]*100] +
+                                    [(t*100) / sumOneVoice * basePercentiles[1] for t in timeList] +
+                                    [(t*100) / summativeMultiSpeaker * basePercentiles[2] for t in multiTimeList],
+                    "parentPercentiles" : [basePercentiles[0]*100,
+                                     basePercentiles[1]*100,
+                                     basePercentiles[2]*100] +
+                                    [(t*100) / sumOneVoice for t in timeList] +
+                                    [(t*100) / summativeMultiSpeaker for t in multiTimeList],
+                    
+                }
+            )
+            df5.name = "df5"
+            st.session_state.summaries[currFileIndex]["df5"] = df5
+            
+            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
+
+            df2_dict = {
+                "values":[100*t/currResults["duration"] for t in df4_dict["values"]],
+                "names":df4_dict["names"]
+            }
+            df2 = pd.DataFrame(df2_dict)
+            st.session_state.summaries[currFileIndex]["df2"] = df2
+    except ValueError:
+        pass
+
+#----------------------------------------------------------------------------------------------------------------------
+
+torch.classes.__path__ = [os.path.join(torch.__path__[0], torch.classes.__file__)]
+
+PARQUET_DATASET_DIR = Path("parquet_dataset")
+PARQUET_DATASET_DIR.mkdir(parents=True,exist_ok=True)
+
+sample_data = [f"CHEM1402_gt/24F_CHEM1402_Night_Class_Week_{i}_gt.rttm" for i in range(1,11)]
+
+
+scheduler = ps.ParquetScheduler(repo_id="Sonogram/SampleDataset")
+
+secondDifference = 5
+gainWindow = 4
+minimumGain = -45
+maximumGain = -5
+attenLimDB = 3
+
+isGPU = False
+
+try:
+    raise(RuntimeError("Not an error"))
+    #device = xm.xla_device()
+    print("TPU is available.")
+    isGPU = True
+except RuntimeError as e:
+    print(f"TPU is not available: {e}")
+    # Fallback to CPU or other devices if needed
+    isGPU = torch.cuda.is_available()
+    device = torch.device("cuda" if isGPU else "cpu")
+    print(f"Using {device} instead.")
+#device = xm.xla_device()
+
+
+# Instantiate and prepare model for training.
+dfModel, dfState, _ = init_df(model_base_dir="DeepFilterNet3")
+dfModel.to(device)#torch.device("cuda"))
+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
+if 'results' not in st.session_state:
+    st.session_state.results = []
+if 'summaries' not in st.session_state:
+    st.session_state.summaries = []
+if 'categories' not in st.session_state:
+    st.session_state.categories = ["Lecturer","Audience"]
+    st.session_state.categorySelect = []
+# Single Use
+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 = []
+if 'file_names' not in st.session_state:
+    st.session_state.file_names = []
     
-def sumTimesPerSpeaker(timeSlotList):
-    speakerList = []
-    timeList = []
-    for speaker,timeSlot in timeSlotList:
-        if speaker not in speakerList:
-            speakerList.append(speaker)
-            timeList.append(0)
-        timeList[speakerList.index(speaker)] += timeSlot.duration
-    return speakerList, timeList
+
     
-def sumMultiTimesPerSpeaker(timeSlotList):
-    speakerList = []
-    timeList = []
-    sList,tList = sumTimesPerSpeaker(timeSlotList)
-    for i,speakerGroup in enumerate(sList):
-        for speaker in speakerGroup:
-            if speaker not in speakerList:
-                speakerList.append(speaker)
-                timeList.append(0)
-            timeList[speakerList.index(speaker)] += tList[i]
-    return speakerList, timeList
+
     
 #st.set_page_config(layout="wide")
 st.title("Lecturer Support Tool")
@@ -259,7 +314,7 @@ if uploaded_file_paths is not None:
     print("Found file paths")
     valid_files = []
     file_paths = []
-    audio_tabs = []
+    file_names = []
     # Reset valid_files?
     for uploaded_file in uploaded_file_paths:
         if not uploaded_file.name.endswith(supported_file_types):
@@ -273,311 +328,277 @@ if uploaded_file_paths is not None:
                     f.write(uploaded_file.getvalue())
                 valid_files.append(uploaded_file)
                 file_paths.append(path)
+    # Save valid file names
     if len(valid_files) > 0:
-        audio_tabs = st.tabs([f.name for f in valid_files])
+        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([])
+    # Clear replaced files
+    for i in range(len(valid_files)):
+        if len(st.session_state.results[i]) > 0 and st.session_state.results[i][0] != file_names[i]:
+            st.session_state.results[i] = []
+            st.session_state.summaries[i] = []
+    st.session_state.file_names = file_names
 
-st.info(f'{len(valid_files)} valid files: {[fi.name for fi in valid_files]}')
+file_names = st.session_state.file_names
+
+currFile = st.sidebar.selectbox('Current File', file_names,on_change=updateMultiSelect,key="select_currFile")
     
-if st.button("Analyze All Audio",key=f"button_all"):
-    if len(valid_files) == 0:
-        st.error('Upload file(s) first!')
-    else:
-        print("Start analyzing")
-        start_time = time.time()
-        totalFiles = len(valid_files)
-        for i in range(totalFiles):
-            with st.spinner(text=f'Analyzing File {i+1} of {totalFiles}'):
-                # Text files use sample data
-                if file_paths[i].endswith('.txt'):
-                    time.sleep(1)
-                    # RTTM load as filler
-                    speakerList, annotations = su.loadAudioRTTM(sample_data[i])
-                    st.session_state.results[i] = (speakerList,annotations, 10000)
-                    st.session_state.summaries[i] = []
-                else:
-                    st.info(file_paths[i])
-                    speakerList, annotations, totalSeconds = processFile(file_paths[i])
-                    st.session_state.results[i] = (speakerList,annotations, totalSeconds)
-                    st.session_state.summaries[i] = []
-        st.success(f"Took {time.time() - start_time} seconds to analyze {totalFiles} files!")
-            
-for i, tab in enumerate(audio_tabs):
-    if tab.button("Analyze Audio",key=f"button_{i}"):
-        start_time = time.time()
-        # Text files use sample data
-        if file_paths[i].endswith('.txt'):
-            with st.spinner(text='NOT ACTUALLY ANALYZING, JUST A FILLER ANIMATION'):
-                time.sleep(1)
-                # RTTM load as filler
-                speakerList, annotations = su.loadAudioRTTM(sample_data[i])
-                st.session_state.results[i] = (speakerList,annotations,10000)
-                st.session_state.summaries[i] = []
+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:
+            st.error('Upload file(s) first!')
         else:
-            with st.spinner(text='Analyzing File'):
-                st.session_state.results[i] = processFile(file_paths[i])
-                st.session_state.summaries[i] = []
-        st.success(f"Took {time.time() - start_time} seconds to analyze!")
-            
-    if len(st.session_state.results) > i and len(st.session_state.summaries) > i and len(st.session_state.results[i]) > 0:
-        with st.spinner(text='Loading results...'):
-            # Display breakdowns
-            #--------------------------------------------------------------------------
-
-            speakerList, annotations, totalSeconds = st.session_state.results[i]
-            
-            # Prepare data
-            sortedSpeakerList = sorted([[row for row in speaker if row[1] > 0.25] for speaker in speakerList if len([row for row in speaker if row[1] > 0.25]) > 0],
-                   key=lambda e: min(e)[0])
-            pred_count = len(sortedSpeakerList)
-            lecturer_speaker_list,_ = su.twoClassExtendAnnotation(annotations)
-            lecturer_pred_count = 2
-            lecturer_speaker_times = []
-            for j,speaker in enumerate(lecturer_speaker_list):
-                lecturer_speaker_times.append(0)
-                for timeSection in speaker:
-                    lecturer_speaker_times[j] += timeSection[1]
-
-            lecturer_dataFrame = su.speakerListToDataFrame(lecturer_speaker_list)
-            lecturer_dataFrame.loc[lecturer_dataFrame['Resource'] == "Speaker 1", 'Resource'] = "Lecturer"
-            lecturer_dataFrame.loc[lecturer_dataFrame['Resource'] == "Speaker 2", 'Resource'] = "Audience"
-            
-            all_speaker_times = []
-            for j,speaker in enumerate(sortedSpeakerList):
-                all_speaker_times.append(0)
-                for timeSection in speaker:
-                    all_speaker_times[j] += timeSection[1]
-
-            all_dataFrame = su.speakerListToDataFrame(sortedSpeakerList)
-            currDF = all_dataFrame
-
-            # TBD CLEAN THIS UP!!!
-            noVoice2, oneVoice2, multiVoice2, rawSample = calcCategories(annotations,totalSeconds)
-            noVoice2.sort()
-            oneVoice2.sort()
-            multiVoice2.sort()
-            sList,timeList = sumTimesPerSpeaker(oneVoice2)
-            multiSpeakerList, multiTimeList = sumMultiTimesPerSpeaker(multiVoice2)
-            
-            multiVoice = annotations.get_overlap()
-            singleVoice = annotations.extrude(multiVoice).get_timeline()
-            noVoice = Timeline(segments=[Segment(0,totalSeconds)]).extrude(singleVoice).extrude(multiVoice)
-            # Pie Categories
-            #---------------------------------------------------------------------------
-            df = pd.DataFrame(
-                {
-                    "Duration": [noVoice.duration(),singleVoice.duration(),multiVoice.duration()],
-                    "Category": ["Silence", "Single Voice", "Multiple Voices"],
-                }
-            )
-            fig = px.pie(df, values='Duration', names='Category', title='Types of Discussion')
-            tab.plotly_chart(fig, use_container_width=True)
-
-            df4: pd.DataFrame = pd.DataFrame(
-                {
-                    "values": [sumTimes(rawSample[key]) for key in rawSample.keys()],
-                    "names": [key for key in rawSample.keys()]
-                }
-            )
-            df4.name = "df4"
-
-            df5: pd.DataFrame = pd.DataFrame(
-                {
-                    "ids" : ["NV","OV","MV"]+[f"OV_{i}" for i in range(len(sList))]
-                                +[f"MV_{i}" for i in range(len(multiSpeakerList))],
-                    "labels" : ["No Voice","One Voice","Multi Voice"] + sList + multiSpeakerList,
-                    "parents" : ["","",""]+["OV" for i in range(len(sList))]
-                                +["MV" for i in range(len(multiSpeakerList))],
-                    "values" : [sumTimes(noVoice2),
-                                sumTimes([n for _,n in oneVoice2]),
-                                sumTimes([n for _,n in multiVoice2]),
-                                ] + timeList + multiTimeList,
-                }
-            )
-            df5.name = "df5"
-
-            fig2 = make_subplots(rows=2, cols=1,
-                specs=[[{"type": "pie"}],[{"type": "treemap"}]]
-                       , shared_xaxes=True)
-            fig2.add_trace(go.Pie(values=df4["values"],labels=df4["names"]),
-              row=1, col=1)
-            fig2.add_trace(go.Treemap(
-                            labels = df5["labels"],
-                            parents = df5["parents"],
-                            ids=df5["ids"],
-                            values = df5["values"]),
-                            row=2, col=1)
-            tab.plotly_chart(fig2, use_container_width=True)
-            
-            # Lecturer vs. Audience
-            #---------------------------------------------------------------------------
-            fig_la = px.timeline(lecturer_dataFrame, x_start="Start", x_end="Finish", y="Resource", color="Resource")
-            fig_la.update_yaxes(autorange="reversed") 
-            
-            
-            hMax = int(totalSeconds//3600)
-            mMax = int(totalSeconds%3600//60)
-            sMax = int(totalSeconds%60)
-            msMax = int(totalSeconds*1000000%1000000)
-            timeMax = dt.time(hMax,mMax,sMax,msMax)
-                    
-            fig_la.update_layout(
-                xaxis_tickformatstops = [
-                    dict(dtickrange=[None, 1000], value="%H:%M:%S.%L"),
-                    dict(dtickrange=[1000, None], value="%H:%M:%S")
-                ],
-                xaxis=dict(
-                        range=[dt.datetime.combine(dt.date.today(), dt.time.min),dt.datetime.combine(dt.date.today(), timeMax)]
-                    ),
-                xaxis_title="Time",
-                yaxis_title="Speaker",
-                legend_title=None
-            )
-            
-            tab.plotly_chart(fig_la, use_container_width=True)
-            
-            dataTimeList = []
-            dataTimeList.append(dict(Task=0,x=lecturer_speaker_times[0]/totalSeconds*100,y=f'Lecturer'))
-            dataTimeList.append(dict(Task=1,x=lecturer_speaker_times[1]/totalSeconds*100,y=f'Audience'))
-            df2 = pd.DataFrame(dataTimeList)
-            fig2_la = px.bar(dataTimeList, x="x", y="y", color="y", orientation='h')
-            fig2_la.update_xaxes(ticksuffix="%")
-            fig2_la.update_yaxes(autorange="reversed") 
-            fig2_la.update_layout(
-                xaxis_title="Percentage Time Spoken",
-                yaxis_title="Speaker",
-                legend_title=None
-                
-            )
-            tab.plotly_chart(fig2_la, use_container_width=True)
-            df = pd.DataFrame(
-                {
-                    "Time spoken": ["{}h:{:02d}m:{:02d}s".format(int(lecturer_speaker_times[0]/3600),
-                                                                int((lecturer_speaker_times[0]%3600)/60),
-                                                                 int(lecturer_speaker_times[0]%60)), 
-                                    "{}h:{:02d}m:{:02d}s".format(int(lecturer_speaker_times[1]/3600),
-                                                                int((lecturer_speaker_times[1]%3600)/60),
-                                                                 int(lecturer_speaker_times[1]%60))],
-                    "Percentage": [
-                        "{:.2f}%".format(100*lecturer_speaker_times[0]/totalSeconds),
-                        "{:.2f}%".format(100*lecturer_speaker_times[1]/totalSeconds),
-                    ],
-                }
-            )
-            df = df.style \
-              .format_index(str.upper, axis=1) \
-              .relabel_index(["Lecturer", "Audience"], axis=0) \
-              #.set_properties(**{"background-color": "white"})
-            tab.write("Total length of audio: {}h:{:02d}m:{:02d}s".format(int(totalSeconds/3600),int((totalSeconds%3600)/60),int(totalSeconds%60)))
-            tab.table(df)
-            #tab.write("Lecturer spoke: {}h:{:02d}m:{:02d}s -> {:.2f}% of time".format(int(lecturer_speaker_times[0]/3600),
-            #                                                                         int((lecturer_speaker_times[0]%3600)/60),int(lecturer_speaker_times[0]%60),
-            #                                                                        100*lecturer_speaker_times[0]/totalSeconds))
-            #tab.write("Audience spoke: {}h:{:02d}m:{:02d}s -> {:.2f}% of time".format(int(lecturer_speaker_times[1]/3600),
-            #                                                                         int((lecturer_speaker_times[1]%3600)/60),int(lecturer_speaker_times[1]%60),
-            #                                                                        100*lecturer_speaker_times[1]/totalSeconds))
-            
-            # Experimental Speaker Breakdown
-            #------------------------------------------------------------------------------
-            fig_spc = px.timeline(all_dataFrame, x_start="Start", x_end="Finish", y="Resource", color="Resource")
-            fig_spc.update_yaxes(autorange="reversed") 
-            
-            
-            hMax = int(totalSeconds//3600)
-            mMax = int(totalSeconds%3600//60)
-            sMax = int(totalSeconds%60)
-            msMax = int(totalSeconds*1000000%1000000)
-            timeMax = dt.time(hMax,mMax,sMax,msMax)
-                    
-            fig_spc.update_layout(
-                xaxis_tickformatstops = [
-                    dict(dtickrange=[None, 1000], value="%H:%M:%S.%L"),
-                    dict(dtickrange=[1000, None], value="%H:%M:%S")
-                ],
-                xaxis=dict(
-                        range=[dt.datetime.combine(dt.date.today(), dt.time.min),dt.datetime.combine(dt.date.today(), timeMax)]
-                    ),
-                xaxis_title="Time",
-                yaxis_title="Speaker",
-                legend_title=None
-            )
-            
-            tab.plotly_chart(fig_spc, use_container_width=True)
-            
-            dataTimeList = []
-            for j, totalTime in enumerate(all_speaker_times):
-                dataTimeList.append(dict(Task=j,x=totalTime/totalSeconds*100,y=f'Speaker {j+1}'))
-            df2 = pd.DataFrame(dataTimeList)
-            fig2_spc = px.bar(dataTimeList, x="x", y="y", color="y", orientation='h')
-            fig2_spc.update_xaxes(ticksuffix="%")
-            fig2_spc.update_yaxes(autorange="reversed") 
-            fig2_spc.update_layout(
-                xaxis_title="Percentage Time Spoken",
-                yaxis_title="Speaker",
-                legend_title=None
+            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  and st.session_state.results[i][0] == file_names[i]:
+                    continue
+                with st.spinner(text=f'Analyzing File {i+1} of {totalFiles}'):
+                    # Text files use sample data
+                    if file_paths[i].endswith('.txt'):
+                        time.sleep(1)
+                        # RTTM load as filler
+                        speakerList, annotations = su.loadAudioRTTM(sample_data[i])
+                        # Approximate total seconds
+                        totalSeconds = 0
+                        for segment in annotations.itersegments():
+                            if segment.end > totalSeconds:
+                                totalSeconds = segment.end
+                        st.session_state.results[i] = (speakerList,annotations, totalSeconds)
+                        st.session_state.summaries[i] = {}
+                        speakerNames = annotations.labels()
+                        st.session_state.unusedSpeakers[i] = speakerNames
+                    else:
+                        st.info(file_paths[i])
+                        speakerList, annotations, totalSeconds = processFile(file_paths[i])
+                        st.session_state.results[i] = (speakerList,annotations, totalSeconds)
+                        st.session_state.summaries[i] = {}
+                        speakerNames = annotations.labels()
+                        st.session_state.unusedSpeakers[i] = speakerNames 
+            st.success(f"Took {time.time() - start_time} seconds to analyze {totalFiles} files!")
+    
+if currFile is None: #Do we need more? -> and len(st.session_state.results) > 0 and len(st.session_state.results[0]) > 0:
+    st.write("Select a file to view from the sidebar")
+try:
+    st.session_state.resetResult = False
+    currFileIndex = file_names.index(currFile)
+    if len(st.session_state.results) > currFileIndex and len(st.session_state.summaries) > currFileIndex and len(st.session_state.results[currFileIndex]) > 0:
+        # Handle 
+        currSpeakerList, currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
+        speakerNames = currAnnotation.labels()
+
+        # Update other categories
+        unusedSpeakers = st.session_state.unusedSpeakers[currFileIndex]
+        categorySelections = st.session_state["categorySelect"][currFileIndex]
+        for i,category in enumerate(st.session_state.categories):
+            speakerSet = categorySelections[i]
+            st.sidebar.multiselect(category,
+                                    speakerSet+unusedSpeakers,
+                                    default=speakerSet,
+                                    key=f"multiselect_{category}",
+                                    on_change=updateCategoryOptions,
+                                    args=(currFileIndex,))
+            st.sidebar.button(f"Remove {category}",key=f"remove_{category}",on_click=removeCategory,args=(i,))
+
+       
+        newCategory = st.sidebar.text_input('Add category', key='categoryInput',on_change=addCategory)   
+
+        df4_dict = {}
+        nameList = st.session_state.categories
+        extraNames = []
+        valueList = [0 for i in range(len(nameList))]
+        extraValues = []
+
+        for i,speakerSet in enumerate(categorySelections):
+            valueList[i] += su.sumTimes(currAnnotation.subset(speakerSet))
+        
+        for sp in unusedSpeakers:
+            extraNames.append(sp)
+            extraValues.append(su.sumTimes(currAnnotation.subset([sp])))
+        
+        df4_dict = {
+                "names": nameList+extraNames,
+                "values": valueList+extraValues,
+            }
+        df4 = pd.DataFrame(data=df4_dict)
+        df4.name = "df4"
+        st.session_state.summaries[currFileIndex]["df4"] = df4
+        
+        df2 = st.session_state.summaries[currFileIndex]["df2"]
+        df3 = st.session_state.summaries[currFileIndex]["df3"]
+        df4 = st.session_state.summaries[currFileIndex]["df4"]
+        df5 = st.session_state.summaries[currFileIndex]["df5"]
+        speakers_dataFrame = st.session_state.summaries[currFileIndex]["speakers_dataFrame"]
+        currDF = speakers_dataFrame
+        speakers_times = st.session_state.summaries[currFileIndex]["speakers_times"]
+       
+        # generate plotting window
+        fig1 = go.Figure()
+        fig1.add_trace(go.Pie(values=df3["values"],labels=df3["names"]))
+        fig2 = go.Figure()
+        fig2.add_trace(go.Pie(values=df4["values"],labels=df4["names"]))
+        fig3_1 = px.sunburst(df5,
+                            branchvalues = 'total',
+                            names = "labels",
+                            ids = "ids",
+                            parents = "parents",
+                            values = "percentiles",
+                            custom_data=['labels','valueStrings','percentiles','parentNames','parentPercentiles'],
+                            color = 'labels',
+                            )
+        fig3_1.update_traces(
+            hovertemplate="<br>".join([
+                '<b>%{customdata[0]}</b>',
+                'Duration: %{customdata[1]}s',
+                'Percentage of Total: %{customdata[2]:.2f}%',
+                'Parent: %{customdata[3]}',
+                'Percentage of Parent: %{customdata[4]:.2f}%'
+            ])
+        )
+        fig3 = px.treemap(df5,
+                        branchvalues = "total",
+                        names = "labels",
+                        parents = "parents",
+                        ids="ids",
+                        values = "percentiles",
+                        custom_data=['labels','valueStrings','percentiles','parentNames','parentPercentiles'],
+                        color='labels',
+                        )
+        fig3.update_traces(
+            hovertemplate="<br>".join([
+                '<b>%{customdata[0]}</b>',
+                'Duration: %{customdata[1]}s',
+                'Percentage of Total: %{customdata[2]:.2f}%',
+                'Parent: %{customdata[3]}',
+                'Percentage of Parent: %{customdata[4]:.2f}%'
+            ])
+        )
+        st.plotly_chart(fig1, use_container_width=True)
+        st.plotly_chart(fig2, use_container_width=True)
+        st.plotly_chart(fig3_1, use_container_width=True)
+        st.plotly_chart(fig3, use_container_width=True)
+
+        fig_la = px.timeline(speakers_dataFrame, x_start="Start", x_end="Finish", y="Resource", color="Resource")
+        fig_la.update_yaxes(autorange="reversed") 
+        
+        hMax = int(currTotalTime//3600)
+        mMax = int(currTotalTime%3600//60)
+        sMax = int(currTotalTime%60)
+        msMax = int(currTotalTime*1000000%1000000)
+        timeMax = dt.time(hMax,mMax,sMax,msMax)
                 
-            )
-            tab.plotly_chart(fig2_spc, use_container_width=True)            
-            
-            df = pd.DataFrame(
-                {
-                    "Time spoken": ["{}h:{:02d}m:{:02d}s".format(int(sp/3600),
-                                                                int((sp%3600)/60),
-                                                                 int(sp%60)) for sp in all_speaker_times],
-                    "Percentage": ["{:.2f}%".format(100*sp/totalSeconds) for sp in all_speaker_times],
-                }
-            )
-            df = df.style \
-              .format_index(str.upper, axis=1) \
-              .relabel_index([f"speaker {sp}" for sp in range(len(all_speaker_times))], axis=0) \
-              #.set_properties(**{"background-color": "white"})
+        fig_la.update_layout(
+            xaxis_tickformatstops = [
+                dict(dtickrange=[None, 1000], value="%H:%M:%S.%L"),
+                dict(dtickrange=[1000, None], value="%H:%M:%S")
+            ],
+            xaxis=dict(
+                    range=[dt.datetime.combine(dt.date.today(), dt.time.min),dt.datetime.combine(dt.date.today(), timeMax)]
+                ),
+            xaxis_title="Time",
+            yaxis_title="Speaker",
+            legend_title=None
+        )
+        
+        st.plotly_chart(fig_la, use_container_width=True)
+        
+        fig2_la = px.bar(df2, x="values", y="names", color="names", orientation='h',
+                        custom_data=["names","values"])
+        fig2_la.update_xaxes(ticksuffix="%")
+        fig2_la.update_yaxes(autorange="reversed") 
+        fig2_la.update_layout(
+            xaxis_title="Percentage Time Spoken",
+            yaxis_title="Speaker",
+            legend_title=None
             
-            tab.write("Total length of audio: {}h:{:02d}m:{:02d}s".format(int(totalSeconds/3600),int((totalSeconds%3600)/60),int(totalSeconds%60)))
-            tab.table(df)
+        )
+        fig2_la.update_traces(
+            hovertemplate="<br>".join([
+                '<b>%{customdata[0]}</b>',
+                'Percentage of Time: %{customdata[1]:.2f}%'
+            ])
+        )
+        st.plotly_chart(fig2_la, use_container_width=True)
+except ValueError:
+    pass
+
+if len(st.session_state.results) > 0:
+    with st.spinner(text='Processing summary results...'):
+        fileNames = []
+        results = []
+        indices = []
+        for i, resultTuple in enumerate(st.session_state.results):
+            if len(resultTuple) == 2:
+                fileNames.append(resultTuple[0])
+                results.append(resultTuple[1])
+                indices.append(i)
+        if len(indices) > 1:
             
-            st.session_state.summaries[i] = [totalSeconds,lecturer_speaker_times,all_speaker_times]
-
-with st.spinner(text='Processing summary results...'):
-    summary_count = 0
-    for su in st.session_state.summaries:
-        if len(su) > 0:
-            summary_count += 1
-
-    if summary_count > 1:
-        valid_summaries = []
-        for ssm in st.session_state.summaries:
-            if len(ssm) > 0:
-                valid_summaries.append(ssm)
-        #st.info(f'{[ssm[0] for ssm in enumerate(valid_summaries)]}')
-        lecturer_data = pd.DataFrame({
-            'ds' : range(summary_count) ,
-            'y' : [100*ssm[1][0]/ssm[0] for ssm in valid_summaries]
-                                     
-        })
-        audience_data = pd.DataFrame({
-            'ds' : range(summary_count) ,
-            'y' : [100*ssm[1][1]/ssm[0] for ssm in valid_summaries]
-                                     
-        })
-        speaker_data = pd.DataFrame({
-            'ds' : range(summary_count) ,
-            'y' : [len(ssm[2]) for ssm in valid_summaries]
-                                     
-        })
-        fig_la = px.line(lecturer_data, x="ds", y="y", color_discrete_sequence=["#0514C0"], labels={'y': 'Lecturer Time'})
-        fig_la.add_scatter(x=audience_data['ds'], y=audience_data['y'], mode='lines', name='Audience Time', line=dict(color='#4CC005'))
-        fig_la.update_layout(title='Percentage of Time Speaking for Lecturer and Audience', xaxis_title='File', yaxis_title='Percent Time Spoken')
-        st.plotly_chart(fig_la, use_container_width=True)
-    
-        fig_spc = px.line(speaker_data, x="ds", y="y", color_discrete_sequence=["#0514C0"], labels={'y': 'Speaker Count'})
-        fig_spc.update_layout(title='Number of Distinct Speakers over Time', xaxis_title='File', yaxis_title='# of Distinct Speakers')
-        st.plotly_chart(fig_spc, use_container_width=True)
-
-    
-userid = st.text_input("user id:", "Guest")
+            df6_dict = {
+                "files":fileNames,
+            }
+            allCategories = copy.deepcopy(st.session_state.categories)
+            for i in indices:
+                currResult = st.session_state.results[i][1]
+                categorySelections = st.session_state["categorySelect"][i]
+                catSummary,extraCats = calcCategories(currResult["speakers"],categorySelections)
+                st.session_state.summaries[i]["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"]
+                theseCategories = st.session_state.categories + extras
+                for j, timeSlots in enumerate(summary):
+                    df6_dict[theseCategories[j]].append(sumTimes([t for _,t in timeSlots])/st.session_state.results[i][1]['duration'])
+                for category in allCategories:
+                    if category not in theseCategories:
+                        df6_dict[category].append(0)
+            df6 = pd.DataFrame(df6_dict)
+            summFig = px.bar(df6, x="files", y=allCategories)
+            st.plotly_chart(summFig, use_container_width=True)
+        
+            voiceNames = ["No Voice","One Voice","Multi Voice"]
+            df7_dict = {
+                "files":[fileName for fileName,_ in st.session_state.results],
+            }
+            for category in voiceNames:
+                df7_dict[category] = []
+            for resultID,summary in enumerate(st.session_state.summaries):
+                partialDf = summary["df5"]
+                for i in range(len(voiceNames)):
+                    df7_dict[voiceNames[i]].append(partialDf["percentiles"][i])
+            df7 = pd.DataFrame(df7_dict)
+            sorted_df7 = df7.sort_values(by=['One Voice', 'Multi Voice'])
+            summFig2 = px.bar(sorted_df7, x="files", y=["One Voice","Multi Voice","No Voice",])
+            st.plotly_chart(summFig2, use_container_width=True)
+            sorted_df7_3 = df7.sort_values(by=['Multi Voice','One Voice'])
+            summFig3 = px.bar(sorted_df7_3, x="files", y=["One Voice","Multi Voice","No Voice",])
+            st.plotly_chart(summFig3, use_container_width=True)
+            sorted_df7_4 = df7.sort_values(by=['No Voice', 'Multi Voice'],ascending=False)
+            summFig4 = px.bar(sorted_df7_4, x="files", y=["One Voice","Multi Voice","No Voice",])
+            st.plotly_chart(summFig4, use_container_width=True)
+
+
+
+old = '''userid = st.text_input("user id:", "Guest")
 colorPref = st.text_input("Favorite color?", "None")
 radio = st.radio('Pick one:', ['Left','Right'])
 selection = st.selectbox('Select', [1,2,3])
@@ -586,7 +607,7 @@ if st.button("Upload Files to Dataset"):
              file_paths,
              userid)
     st.success('I think it worked!')
-
+'''
 @st.cache_data
 def convert_df(df):
    return df.to_csv(index=False).encode('utf-8')