Updated html to json

shared.py

@@ -455,43 +455,100 @@ class RealtimeSpeakerDiarization:
         return f"Settings updated: Threshold={threshold:.2f}, Max Speakers={max_speakers}"
     
     def get_formatted_conversation(self):
-        """Get the formatted conversation"""
-        return self.current_conversation
+        """Get the formatted conversation with structured data"""
+        try:
+            # Create conversation HTML format as before
+            html_content = self.current_conversation
+            
+            # Create structured data
+            structured_data = {
+                "html_content": html_content,
+                "sentences": [],
+                "current_transcript": self.last_transcription,
+                "current_speaker": self.speaker_detector.current_speaker if self.speaker_detector else 0
+            }
+            
+            # Add sentence data
+            for sentence_text, speaker_id in self.full_sentences:
+                color = self.speaker_detector.get_color_for_speaker(speaker_id) if self.speaker_detector else "#FFFFFF"
+                structured_data["sentences"].append({
+                    "text": sentence_text,
+                    "speaker_id": speaker_id,
+                    "speaker_name": f"Speaker {speaker_id + 1}",
+                    "color": color
+                })
+            
+            return html_content
+        except Exception as e:
+            logger.error(f"Error formatting conversation: {e}")
+            return f"<i>Error formatting conversation: {str(e)}</i>"
     
     def get_status_info(self):
-        """Get current status information"""
+        """Get current status information as structured data"""
         if not self.speaker_detector:
-            return "Speaker detector not initialized"
+            return {"error": "Speaker detector not initialized"}
         
         try:
-            status = self.speaker_detector.get_status_info()
+            speaker_status = self.speaker_detector.get_status_info()
             
+            # Format speaker activity
+            speaker_activity = []
+            for i in range(speaker_status['max_speakers']):
+                color_name = SPEAKER_COLOR_NAMES[i] if i < len(SPEAKER_COLOR_NAMES) else f"Speaker {i+1}"
+                count = speaker_status['speaker_counts'][i]
+                active = count > 0
+                speaker_activity.append({
+                    "id": i,
+                    "name": f"Speaker {i+1}",
+                    "color": SPEAKER_COLORS[i] if i < len(SPEAKER_COLORS) else "#FFFFFF",
+                    "color_name": color_name,
+                    "segment_count": count,
+                    "active": active
+                })
+            
+            # Create structured status object
+            status = {
+                "current_speaker": speaker_status['current_speaker'],
+                "current_speaker_name": f"Speaker {speaker_status['current_speaker'] + 1}",
+                "active_speakers_count": speaker_status['active_speakers'],
+                "max_speakers": speaker_status['max_speakers'],
+                "last_similarity": speaker_status['last_similarity'],
+                "change_threshold": speaker_status['threshold'],
+                "total_sentences": len(self.full_sentences),
+                "segments_processed": speaker_status['segment_counter'],
+                "speaker_activity": speaker_activity,
+                "timestamp": time.time()
+            }
+            
+            # Also create a formatted text version for UI display
             status_lines = [
                 f"**Current Speaker:** {status['current_speaker'] + 1}",
-                f"**Active Speakers:** {status['active_speakers']} of {status['max_speakers']}",
+                f"**Active Speakers:** {status['active_speakers_count']} of {status['max_speakers']}",
                 f"**Last Similarity:** {status['last_similarity']:.3f}",
-                f"**Change Threshold:** {status['threshold']:.2f}",
-                f"**Total Sentences:** {len(self.full_sentences)}",
-                f"**Segments Processed:** {status['segment_counter']}",
+                f"**Change Threshold:** {status['change_threshold']:.2f}",
+                f"**Total Sentences:** {status['total_sentences']}",
+                f"**Segments Processed:** {status['segments_processed']}",
                 "",
                 "**Speaker Activity:**"
             ]
             
-            for i in range(status['max_speakers']):
-                color_name = SPEAKER_COLOR_NAMES[i] if i < len(SPEAKER_COLOR_NAMES) else f"Speaker {i+1}"
-                count = status['speaker_counts'][i]
-                active = "🟢" if count > 0 else "⚫"
-                status_lines.append(f"{active} Speaker {i+1} ({color_name}): {count} segments")
+            for speaker in status["speaker_activity"]:
+                active = "🟢" if speaker["active"] else "⚫"
+                status_lines.append(f"{active} Speaker {speaker['id']+1} ({speaker['color_name']}): {speaker['segment_count']} segments")
             
-            return "\n".join(status_lines)
+            status["formatted_text"] = "\n".join(status_lines)
+            
+            return status
             
         except Exception as e:
-            return f"Error getting status: {e}"
+            error_msg = f"Error getting status: {e}"
+            logger.error(error_msg)
+            return {"error": error_msg, "formatted_text": error_msg}
 
     def process_audio_chunk(self, audio_data, sample_rate=16000):
         """Process audio chunk from WebSocket input"""
         if not self.is_running or self.audio_processor is None:
-            return
+            return {"status": "not_running"}
             
         try:
             # Convert bytes to numpy array if needed
@@ -517,6 +574,10 @@ class RealtimeSpeakerDiarization:
             self.audio_processor.add_audio_chunk(audio_data)
             
             # Periodically extract embeddings for speaker detection
+            embedding = None
+            speaker_id = self.speaker_detector.current_speaker
+            similarity = 1.0
+            
             if len(self.audio_processor.audio_buffer) % (SAMPLE_RATE // 2) == 0:  # Every 0.5 seconds
                 embedding = self.audio_processor.extract_embedding_from_buffer()
                 if embedding is not None:
@@ -527,9 +588,18 @@ class RealtimeSpeakerDiarization:
                         with self.transcription_lock:
                             self.full_sentences.append((f"[Audio segment {self.speaker_detector.segment_counter}]", speaker_id))
                             self.update_conversation_display()
+            
+            # Return processing result
+            return {
+                "status": "processed", 
+                "buffer_size": len(self.audio_processor.audio_buffer),
+                "speaker_id": speaker_id,
+                "similarity": similarity if embedding is not None else None
+            }
                     
         except Exception as e:
             logger.error(f"Error processing audio chunk: {e}")
+            return {"status": "error", "message": str(e)}
     
     def resample_audio(self, audio_bytes, from_rate, to_rate):
         """Resample audio to target sample rate"""

ui.py

@@ -173,10 +173,57 @@ def build_ui():
                         };
                         
                         wsConnection.onmessage = (event) => {
-                            document.getElementById("conversation").innerHTML = event.data;
-                            // Auto-scroll to bottom
-                            const container = document.getElementById("conversation");
-                            container.scrollTop = container.scrollHeight;
+                            try {
+                                // Parse the JSON message
+                                const message = JSON.parse(event.data);
+                                
+                                // Process different message types
+                                switch(message.type) {
+                                    case 'transcription':
+                                        // Handle transcription data
+                                        if (message.data && typeof message.data === 'object') {
+                                            document.getElementById("conversation").innerHTML = message.data.conversation_html || 
+                                                JSON.stringify(message.data);
+                                        }
+                                        break;
+                                        
+                                    case 'connection':
+                                        console.log('Connection status:', message.status);
+                                        updateStatus(message.status === 'connected' ? 'connected' : 'warning');
+                                        break;
+                                        
+                                    case 'conversation_update':
+                                        if (message.conversation_html) {
+                                            document.getElementById("conversation").innerHTML = message.conversation_html;
+                                        }
+                                        break;
+                                        
+                                    case 'conversation_cleared':
+                                        document.getElementById("conversation").innerHTML = 
+                                            "<i>Conversation cleared. Start speaking again...</i>";
+                                        break;
+                                        
+                                    case 'error':
+                                        console.error('Error message from server:', message.message);
+                                        updateStatus('warning', message.message);
+                                        break;
+                                        
+                                    default:
+                                        // If it's just HTML content without proper JSON structure (legacy format)
+                                        document.getElementById("conversation").innerHTML = event.data;
+                                }
+                                
+                                // Auto-scroll to bottom
+                                const container = document.getElementById("conversation");
+                                container.scrollTop = container.scrollHeight;
+                            } catch (e) {
+                                // Fallback for non-JSON messages (legacy format)
+                                document.getElementById("conversation").innerHTML = event.data;
+                                
+                                // Auto-scroll to bottom
+                                const container = document.getElementById("conversation");
+                                container.scrollTop = container.scrollHeight;
+                            }
                         };
                         
                         wsConnection.onerror = (error) => {