Update app.py

app.py

@@ -24,7 +24,7 @@ from config import NVIDIA_THEME, DEFAULT_SETTINGS
 
 # Konfiguracja strony
 st.set_page_config(
-    page_title="QualiInsightLab - FGI/IDI Research Analyzer",
+    page_title="QualiInsightLab",
     page_icon="🎙️",
     layout="wide",
     initial_sidebar_state="expanded"
@@ -101,19 +101,36 @@ class FGIIDIAnalyzer:
         if 'overall_progress' not in st.session_state:
             st.session_state.overall_progress = 0
     
-    def log_message(self, message, level="INFO"):
-        """Dodaj wiadomość do logów"""
+    def log_message(self, message, level="INFO", force_local=False):
+        """Dodaj wiadomość do logów - thread-safe"""
         timestamp = datetime.now().strftime("%H:%M:%S")
         log_entry = f"[{timestamp}] {level}: {message}"
-        st.session_state.logs.append(log_entry)
         
-        # Ograniczenie liczby logów do 100
-        if len(st.session_state.logs) > 100:
-            st.session_state.logs = st.session_state.logs[-100:]
+        try:
+            # Sprawdź czy jesteśmy w głównym wątku Streamlit
+            if not force_local and 'logs' in st.session_state:
+                st.session_state.logs.append(log_entry)
+                
+                # Ograniczenie liczby logów do 100
+                if len(st.session_state.logs) > 100:
+                    st.session_state.logs = st.session_state.logs[-100:]
+            else:
+                # Fallback dla wątków - zapisz do lokalnej listy
+                if not hasattr(self, 'local_logs'):
+                    self.local_logs = []
+                self.local_logs.append(log_entry)
+                
+                # Wyświetl w konsoli jeśli jesteśmy w wątku
+                print(log_entry)
+                
+        except Exception as e:
+            # Ostateczny fallback
+            print(f"LOG ERROR: {log_entry}")
+            print(f"LOG ERROR DETAILS: {e}")
     
     def render_sidebar(self):
         """Renderuj sidebar z konfiguracją"""
-        st.sidebar.title("🎙️ FGI/IDI Analyzer")
+        st.sidebar.title("🎙️ QualiInsightLab")
         st.sidebar.markdown("---")
         
         # API Keys
@@ -183,7 +200,43 @@ class FGIIDIAnalyzer:
             'language': language
         }
     
-    def cleanup_session(self):
+    def update_progress_safe(self, progress_value, status_message):
+        """Thread-safe aktualizacja postępu"""
+        try:
+            st.session_state.overall_progress = progress_value
+            st.session_state.current_file_progress = status_message
+        except:
+            # Fallback - wyświetl w konsoli
+            print(f"PROGRESS: {progress_value:.1%} - {status_message}")
+    
+    def update_transcriptions_safe(self, filename, transcription):
+        """Thread-safe aktualizacja transkrypcji"""
+        try:
+            st.session_state.transcriptions[filename] = transcription
+        except:
+            # Fallback - zapisz do lokalnej zmiennej
+            if not hasattr(self, 'local_transcriptions'):
+                self.local_transcriptions = {}
+            self.local_transcriptions[filename] = transcription
+            print(f"TRANSCRIPTION: {filename} completed locally")
+    
+    def sync_local_data(self):
+        """Synchronizuj dane lokalne z session_state"""
+        try:
+            # Przenies logi lokalne do session_state
+            if hasattr(self, 'local_logs'):
+                for log in self.local_logs:
+                    st.session_state.logs.append(log)
+                self.local_logs = []
+            
+            # Przenies transkrypcje lokalne do session_state
+            if hasattr(self, 'local_transcriptions'):
+                for filename, transcription in self.local_transcriptions.items():
+                    st.session_state.transcriptions[filename] = transcription
+                self.local_transcriptions = {}
+                
+        except Exception as e:
+            print(f"SYNC ERROR: {e}")
         """Wyczyść sesję i pliki tymczasowe"""
         # Zatrzymaj przetwarzanie jeśli trwa
         if st.session_state.processing_status == 'running':
@@ -346,6 +399,9 @@ class FGIIDIAnalyzer:
         """Renderuj postęp przetwarzania"""
         progress_container = st.container()
         
+        # Synchronizuj dane z wątku
+        self.sync_local_data()
+        
         with progress_container:
             # Overall progress bar
             st.progress(st.session_state.overall_progress)
@@ -365,25 +421,30 @@ class FGIIDIAnalyzer:
                 st.rerun()
     
     def process_files_async(self, settings):
-        """Asynchroniczne przetwarzanie plików"""
+        """Asynchroniczne przetwarzanie plików - thread-safe"""
         try:
-            self.log_message("🚀 Rozpoczynam przetwarzanie plików")
+            self.log_message("🚀 Rozpoczynam przetwarzanie plików", force_local=True)
             
             total_files = len(st.session_state.uploaded_files)
             
             # ETAP 1: Transkrypcja plików
             for i, file_info in enumerate(st.session_state.uploaded_files):
-                if st.session_state.processing_status != 'running':
-                    self.log_message("⏹️ Przetwarzanie zatrzymane przez użytkownika")
-                    break
+                # Sprawdź status w bezpieczny sposób
+                try:
+                    if st.session_state.processing_status != 'running':
+                        self.log_message("⏹️ Przetwarzanie zatrzymane przez użytkownika", force_local=True)
+                        return
+                except:
+                    # Jeśli nie można sprawdzić statusu, zakończ
+                    print("Cannot access session_state status - stopping")
+                    return
                 
                 try:
                     # Update progress
                     progress = i / (total_files + 1)  # +1 for report generation
-                    st.session_state.overall_progress = progress
-                    st.session_state.current_file_progress = f"🎙️ Transkrybuję: {file_info['name']}"
+                    self.update_progress_safe(progress, f"🎙️ Transkrybuję: {file_info['name']}")
                     
-                    self.log_message(f"📝 Rozpoczynam transkrypcję: {file_info['name']}")
+                    self.log_message(f"📝 Rozpoczynam transkrypcję: {file_info['name']}", force_local=True)
                     
                     # Przetwórz plik (kompresja/podział jeśli potrzeba)
                     processed_files = self.file_handler.process_file(
@@ -400,7 +461,7 @@ class FGIIDIAnalyzer:
                     for pf in processed_files:
                         file_size_mb = os.path.getsize(pf) / (1024 * 1024)
                         if file_size_mb > 25:
-                            self.log_message(f"⚠️ Część {pf} za duża: {file_size_mb:.1f}MB", "WARNING")
+                            self.log_message(f"⚠️ Część {pf} za duża: {file_size_mb:.1f}MB", "WARNING", force_local=True)
                         else:
                             valid_parts.append(pf)
                     
@@ -414,47 +475,102 @@ class FGIIDIAnalyzer:
                     )
                     
                     if transcription:
-                        st.session_state.transcriptions[file_info['name']] = transcription
-                        self.log_message(f"✅ Transkrypcja zakończona: {file_info['name']}")
+                        self.update_transcriptions_safe(file_info['name'], transcription)
+                        self.log_message(f"✅ Transkrypcja zakończona: {file_info['name']}", force_local=True)
                     else:
-                        self.log_message(f"❌ Transkrypcja nieudana: {file_info['name']}", "ERROR")
+                        self.log_message(f"❌ Transkrypcja nieudana: {file_info['name']}", "ERROR", force_local=True)
                         
                 except Exception as e:
-                    self.log_message(f"❌ Błąd przetwarzania {file_info['name']}: {str(e)}", "ERROR")
+                    self.log_message(f"❌ Błąd przetwarzania {file_info['name']}: {str(e)}", "ERROR", force_local=True)
                     continue
             
             # ETAP 2: Generowanie raportu
-            if st.session_state.transcriptions and st.session_state.processing_status == 'running':
-                st.session_state.current_file_progress = "📄 Generuję raport badawczy..."
-                st.session_state.overall_progress = 0.9
-                
-                self.log_message("📄 Rozpoczynam generowanie raportu")
+            try:
+                # Sprawdź czy mamy transkrypcje (lokalnie lub w session_state)
+                transcriptions_to_use = {}
                 
+                # Zbierz transkrypcje z session_state
                 try:
+                    transcriptions_to_use.update(st.session_state.transcriptions)
+                except:
+                    pass
+                
+                # Dodaj lokalne transkrypcje jeśli są
+                if hasattr(self, 'local_transcriptions'):
+                    transcriptions_to_use.update(self.local_transcriptions)
+                
+                if transcriptions_to_use:
+                    self.update_progress_safe(0.9, "📄 Generuję raport badawczy...")
+                    self.log_message("📄 Rozpoczynam generowanie raportu", force_local=True)
+                    
+                    # Pobierz brief z session_state
+                    try:
+                        brief = st.session_state.research_brief
+                    except:
+                        brief = ""
+                    
                     final_report = self.report_generator.generate_comprehensive_report(
-                        st.session_state.transcriptions,
-                        st.session_state.research_brief
+                        transcriptions_to_use,
+                        brief
                     )
                     
-                    st.session_state.final_report = final_report
-                    st.session_state.processing_status = 'completed'
-                    st.session_state.overall_progress = 1.0
-                    st.session_state.current_file_progress = "✅ Zakończono!"
+                    # Zapisz raport
+                    try:
+                        st.session_state.final_report = final_report
+                        st.session_state.processing_status = 'completed'
+                    except:
+                        # Fallback - zapisz lokalnie
+                        self.local_final_report = final_report
+                        print("REPORT: Generated and saved locally")
                     
-                    self.log_message("🎉 Raport wygenerowany pomyślnie!")
+                    self.update_progress_safe(1.0, "✅ Zakończono!")
+                    self.log_message("🎉 Raport wygenerowany pomyślnie!", force_local=True)
                     
-                except Exception as e:
-                    self.log_message(f"❌ Błąd generowania raportu: {str(e)}", "ERROR")
+                else:
+                    self.log_message("❌ Brak transkrypcji do wygenerowania raportu", "ERROR", force_local=True)
+                    try:
+                        st.session_state.processing_status = 'error'
+                    except:
+                        print("ERROR: No transcriptions available")
+                        
+            except Exception as e:
+                self.log_message(f"❌ Błąd generowania raportu: {str(e)}", "ERROR", force_local=True)
+                try:
                     st.session_state.processing_status = 'error'
+                except:
+                    print(f"REPORT ERROR: {e}")
             
-            else:
-                if not st.session_state.transcriptions:
-                    self.log_message("❌ Brak transkrypcji do wygenerowania raportu", "ERROR")
-                    st.session_state.processing_status = 'error'
+        except Exception as e:
+            self.log_message(f"💥 Błąd krytyczny: {str(e)}", "ERROR", force_local=True)
+            try:
+                st.session_state.processing_status = 'error'
+            except:
+                print(f"CRITICAL ERROR: {e}")
+    
+    def sync_local_data(self):
+        """Synchronizuj dane lokalne z session_state"""
+        try:
+            # Przenies logi lokalne do session_state
+            if hasattr(self, 'local_logs'):
+                for log in self.local_logs:
+                    if 'logs' in st.session_state:
+                        st.session_state.logs.append(log)
+                self.local_logs = []
+            
+            # Przenies transkrypcje lokalne do session_state
+            if hasattr(self, 'local_transcriptions'):
+                for filename, transcription in self.local_transcriptions.items():
+                    st.session_state.transcriptions[filename] = transcription
+                self.local_transcriptions = {}
+            
+            # Przenies raport lokalny do session_state
+            if hasattr(self, 'local_final_report'):
+                st.session_state.final_report = self.local_final_report
+                st.session_state.processing_status = 'completed'
+                delattr(self, 'local_final_report')
                 
         except Exception as e:
-            self.log_message(f"💥 Błąd krytyczny: {str(e)}", "ERROR")
-            st.session_state.processing_status = 'error'
+            print(f"SYNC ERROR: {e}")
     
     def render_results(self):
         """Renderuj wyniki"""
@@ -531,7 +647,7 @@ class FGIIDIAnalyzer:
             settings = self.render_sidebar()
             
             # Main content
-            st.title("🎙️ FGI/IDI Research Analyzer")
+            st.title("🎙️ QualiInsightLab")
             st.markdown("*Automatyczna transkrypcja i analiza wywiadów fokusowych oraz indywidualnych*")
             st.markdown("---")