Update app.py

app.py

@@ -1,5 +1,10 @@
 import streamlit as st
+import os
+from datetime import datetime
+import time
+import traceback
 
+# Konfiguracja strony MUSI być pierwsza
 st.set_page_config(
     page_title="QualiInsightLab",
     page_icon="🎙️",
@@ -7,46 +12,11 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Teraz importy i reszta kodu
-import sys
-import os
-from datetime import datetime
-import time
-import traceback
-import threading
-import queue
-
-# Sprawdzenie zależności BEZ używania st.success/st.error przed set_page_config
-try:
-    import openai
-    OPENAI_AVAILABLE = True
-    openai_status = "✅ OpenAI library loaded successfully"
-except ImportError as e:
-    OPENAI_AVAILABLE = False
-    openai_status = f"❌ OpenAI library missing: {e}"
-
-# Import modułów (bez używania Streamlit commands)
-try:
-    from transcription import AudioTranscriber
-    from report_generator import ReportGenerator
-    from file_handler import FileHandler
-    from config import NVIDIA_THEME, DEFAULT_SETTINGS
-    modules_loaded = True
-except ImportError as e:
-    modules_loaded = False
-    import_error = str(e)
-
-# Teraz możemy użyć komend Streamlit
-if OPENAI_AVAILABLE:
-    st.success(openai_status)
-else:
-    st.error(openai_status)
-    st.info("Installing dependencies... Refresh page in 30 seconds.")
-    st.stop()
-
-if not modules_loaded:
-    st.error(f"❌ Błąd importu modułów: {import_error}")
-    st.stop()
+# Import modułów
+from transcription import AudioTranscriber
+from report_generator import ReportGenerator
+from file_handler import FileHandler
+from config import NVIDIA_THEME, DEFAULT_SETTINGS
 
 # Custom CSS - kolorystyka NVIDIA
 st.markdown(f"""
@@ -95,11 +65,6 @@ class FGIIDIAnalyzer:
         self.report_generator = None
         self.file_handler = FileHandler()
         self.initialize_session_state()
-        
-        # Queue dla komunikacji między wątkami
-        self.status_queue = queue.Queue()
-        self.processing_thread = None
-        self.processing_completed = False
     
     def initialize_session_state(self):
         """Inicjalizacja session state"""
@@ -115,106 +80,19 @@ class FGIIDIAnalyzer:
             st.session_state.research_brief = ""
         if 'logs' not in st.session_state:
             st.session_state.logs = []
-        if 'current_file_progress' not in st.session_state:
-            st.session_state.current_file_progress = ""
-        if 'overall_progress' not in st.session_state:
-            st.session_state.overall_progress = 0
     
-    def log_message(self, message, level="INFO", force_local=False):
-        """Dodaj wiadomość do logów - thread-safe"""
+    def log_message(self, message, level="INFO"):
+        """Dodaj wiadomość do logów"""
         timestamp = datetime.now().strftime("%H:%M:%S")
         log_entry = f"[{timestamp}] {level}: {message}"
+        st.session_state.logs.append(log_entry)
         
-        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 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:
-                    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'
-                st.session_state.overall_progress = 1.0
-                st.session_state.current_file_progress = "✅ Zakończono!"
-                delattr(self, 'local_final_report')
-            
-            # Sprawdź flagę zakończenia
-            if hasattr(self, 'processing_completed') and self.processing_completed:
-                st.session_state.processing_status = 'completed'
-                st.session_state.overall_progress = 1.0
-                st.session_state.current_file_progress = "✅ Zakończono!"
-                self.processing_completed = False
-                
-        except Exception as e:
-            print(f"SYNC ERROR: {e}")
-    
-    def cleanup_session(self):
-        """Wyczyść sesję i pliki tymczasowe"""
-        # Zatrzymaj przetwarzanie jeśli trwa
-        if st.session_state.processing_status == 'running':
-            st.session_state.processing_status = 'stopped'
+        # Ograniczenie liczby logów do 100
+        if len(st.session_state.logs) > 100:
+            st.session_state.logs = st.session_state.logs[-100:]
         
-        # Wyczyść pliki tymczasowe
-        self.file_handler.cleanup_temp_files()
-        
-        # Wyczyść session state
-        for key in list(st.session_state.keys()):
-            del st.session_state[key]
-        
-        self.initialize_session_state()
+        # Wyświetl też w konsoli dla debug
+        print(log_entry)
     
     def render_sidebar(self):
         """Renderuj sidebar z konfiguracją"""
@@ -278,7 +156,8 @@ class FGIIDIAnalyzer:
         
         # Reset session
         if st.sidebar.button("🔄 Reset sesji", type="secondary"):
-            self.cleanup_session()
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
             st.rerun()
         
         return {
@@ -312,7 +191,7 @@ class FGIIDIAnalyzer:
         )
         
         if uploaded_files:
-            # Walidacja plików z nową metodą
+            # Walidacja plików
             valid_files = []
             total_size = 0
             
@@ -320,27 +199,23 @@ class FGIIDIAnalyzer:
                 file_size_mb = file.size / (1024 * 1024)
                 total_size += file_size_mb
                 
-                # Użyj nowej walidacji dla Whisper
-                is_valid, message = self.file_handler.validate_file_for_whisper(file)
-                
-                if not is_valid:
-                    st.error(f"❌ {file.name}: {message}")
+                # Sprawdź rozmiar pojedynczego pliku
+                if file_size_mb > 100:  # 100MB limit dla pojedynczego pliku
+                    st.error(f"❌ {file.name}: Plik za duży ({file_size_mb:.1f}MB). Maksymalnie 100MB.")
                     continue
                 
-                # Pobierz szczegółowe info o pliku
-                file_info = self.file_handler.get_file_info(file)
-                file_info['file'] = file  # Dodaj obiekt pliku
-                valid_files.append(file_info)
+                valid_files.append({
+                    'file': file,
+                    'name': file.name,
+                    'size_mb': file_size_mb,
+                    'needs_splitting': file_size_mb > settings['max_file_size'],
+                    'needs_compression': file_size_mb > 25  # Whisper limit
+                })
             
             # Wyświetl informacje o plikach
             if valid_files:
                 st.success(f"✅ Załadowano {len(valid_files)} plików ({total_size:.1f}MB)")
                 
-                # Pokaż plan przetwarzania
-                if any(not f['whisper_ready'] for f in valid_files):
-                    plan = self.file_handler.create_processing_plan([f['file'] for f in valid_files])
-                    st.info(plan)
-                
                 # Tabela z informacjami o plikach
                 for i, file_info in enumerate(valid_files):
                     col1, col2, col3 = st.columns([3, 1, 1])
@@ -352,12 +227,10 @@ class FGIIDIAnalyzer:
                         st.write(f"{file_info['size_mb']:.1f}MB")
                     
                     with col3:
-                        if file_info['too_large']:
-                            st.error("Za duży")
+                        if file_info['needs_compression']:
+                            st.warning("Kompresja")
                         elif file_info['needs_splitting']:
                             st.warning("Podział")
-                        elif file_info['needs_compression']:
-                            st.warning("Kompresja")
                         else:
                             st.success("OK")
                 
@@ -378,51 +251,24 @@ class FGIIDIAnalyzer:
         
         st.header("🚀 Przetwarzanie")
         
-        # Estymacja czasu i kosztów
-        if st.session_state.processing_status == 'ready':
-            total_size = sum(f['size_mb'] for f in st.session_state.uploaded_files)
-            estimated_time = total_size * 0.5  # ~30s per MB
-            estimated_cost = total_size * 0.1  # ~$0.10 per MB
-            
-            st.info(f"""
-📊 **Estymacja:**
-- Całkowity rozmiar: {total_size:.1f}MB
-- Szacowany czas: {estimated_time:.1f} minut
-- Szacowany koszt: ${estimated_cost:.2f}
-            """)
-        
-        # Przycisk start/stop
+        # Przycisk start
         if st.session_state.processing_status == 'ready':
             if st.button("🎯 Rozpocznij transkrypcję i analizę", type="primary"):
                 st.session_state.processing_status = 'running'
-                st.session_state.current_file_progress = ""
-                st.session_state.overall_progress = 0
-                
-                # Przekaż dane do wątku (kopiuj dane z session_state)
-                files_copy = st.session_state.uploaded_files.copy()
-                brief_copy = st.session_state.research_brief
-                
-                # Uruchom przetwarzanie w osobnym wątku
-                self.processing_thread = threading.Thread(
-                    target=self.process_files_async,
-                    args=(settings, files_copy, brief_copy)
-                )
-                self.processing_thread.start()
-                st.rerun()
+                # Przetwarzaj synchronicznie - PROSTSZE I DZIAŁA
+                self.process_files(settings)
         
         elif st.session_state.processing_status == 'running':
             st.info("⏳ Przetwarzanie w toku...")
-            
-            if st.button("⏹️ Zatrzymaj", type="secondary"):
-                st.session_state.processing_status = 'stopped'
-                st.warning("Przetwarzanie zostanie zatrzymane...")
-                st.rerun()
+            # Podczas przetwarzania nie pokazuj przycisku stop - może powodować problemy
         
         elif st.session_state.processing_status == 'completed':
             st.success("🎉 Przetwarzanie zakończone pomyślnie!")
             
             if st.button("🔄 Nowe przetwarzanie", type="primary"):
                 st.session_state.processing_status = 'ready'
+                st.session_state.transcriptions = {}
+                st.session_state.final_report = None
                 st.rerun()
         
         elif st.session_state.processing_status == 'error':
@@ -431,79 +277,24 @@ class FGIIDIAnalyzer:
             if st.button("🔄 Spróbuj ponownie", type="primary"):
                 st.session_state.processing_status = 'ready'
                 st.rerun()
-        
-        # Progress display
-        if st.session_state.processing_status == 'running':
-            self.render_progress()
-    
-    def render_progress(self):
-        """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)
-            
-            # Current status
-            if st.session_state.current_file_progress:
-                st.info(st.session_state.current_file_progress)
-            
-            # Files completed
-            total_files = len(st.session_state.uploaded_files)
-            completed_files = len(st.session_state.transcriptions)
-            st.write(f"📊 Ukończono: {completed_files}/{total_files} plików")
-            
-            # Auto-refresh podczas przetwarzania
-            if st.session_state.processing_status == 'running':
-                # Sprawdź czy wątek się zakończył
-                if (hasattr(self, 'processing_thread') and 
-                    self.processing_thread is not None and 
-                    not self.processing_thread.is_alive()):
-                    # Wątek się zakończył - sprawdź czy mamy raport
-                    if hasattr(self, 'local_final_report'):
-                        st.session_state.final_report = self.local_final_report
-                        st.session_state.processing_status = 'completed'
-                        st.session_state.overall_progress = 1.0
-                        st.session_state.current_file_progress = "✅ Zakończono!"
-                        delattr(self, 'local_final_report')
-                        st.rerun()
-                    elif len(st.session_state.transcriptions) > 0:
-                        # Mamy transkrypcje ale brak raportu - możliwy błąd
-                        st.session_state.processing_status = 'error'
-                        st.rerun()
-                
-                time.sleep(2)
-                st.rerun()
     
-    def process_files_async(self, settings, uploaded_files, research_brief):
-        """Asynchroniczne przetwarzanie plików - thread-safe z przekazanymi danymi"""
+    def process_files(self, settings):
+        """Główna logika przetwarzania plików - SYNCHRONICZNA"""
         try:
-            self.log_message("🚀 Rozpoczynam przetwarzanie plików", force_local=True)
+            self.log_message("🚀 Rozpoczynam przetwarzanie plików")
             
-            total_files = len(uploaded_files)
+            # Container dla live updates
+            status_container = st.empty()
+            progress_container = st.empty()
             
-            # ETAP 1: Transkrypcja plików
-            for i, file_info in enumerate(uploaded_files):
-                # 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, kontynuuj (może być w middle of processing)
-                    pass
+            # 1. Transkrypcja wszystkich plików
+            for i, file_info in enumerate(st.session_state.uploaded_files):
+                
+                status_container.info(f"🎙️ Transkrybuję: {file_info['name']} ({i+1}/{len(st.session_state.uploaded_files)})")
+                self.log_message(f"📝 Rozpoczynam transkrypcję: {file_info['name']}")
                 
                 try:
-                    # Update progress
-                    progress = i / (total_files + 1)  # +1 for report generation
-                    self.update_progress_safe(progress, f"🎙️ Transkrybuję: {file_info['name']}")
-                    
-                    self.log_message(f"📝 Rozpoczynam transkrypcję: {file_info['name']}", force_local=True)
-                    
-                    # Przetwórz plik (kompresja/podział jeśli potrzeba)
+                    # Przetwórz plik (podział jeśli potrzeba)
                     processed_files = self.file_handler.process_file(
                         file_info['file'], 
                         settings['max_file_size'],
@@ -513,98 +304,56 @@ class FGIIDIAnalyzer:
                     if not processed_files:
                         raise Exception("Nie udało się przetworzyć pliku")
                     
-                    # Walidacja rozmiaru wszystkich części
-                    valid_parts = []
-                    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", force_local=True)
-                        else:
-                            valid_parts.append(pf)
-                    
-                    if not valid_parts:
-                        raise Exception("Wszystkie części za duże dla Whisper API")
-                    
-                    # Transkrypcja z retry logic
+                    # Transkrypcja
                     transcription = self.transcriber.transcribe_files(
-                        valid_parts,
+                        processed_files,
                         language=settings['language']
                     )
                     
-                    if transcription:
-                        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", force_local=True)
-                        
+                    st.session_state.transcriptions[file_info['name']] = transcription
+                    self.log_message(f"✅ Zakończono transkrypcję: {file_info['name']}")
+                    
+                    # Update progress
+                    progress = (i + 1) / len(st.session_state.uploaded_files)
+                    progress_container.progress(progress)
+                    
                 except Exception as e:
-                    self.log_message(f"❌ Błąd przetwarzania {file_info['name']}: {str(e)}", "ERROR", force_local=True)
+                    self.log_message(f"❌ Błąd transkrypcji {file_info['name']}: {str(e)}", "ERROR")
+                    st.error(f"Błąd przy {file_info['name']}: {str(e)}")
                     continue
             
-            # ETAP 2: Generowanie raportu
-            try:
-                # Sprawdź czy mamy transkrypcje (lokalnie lub w session_state)
-                transcriptions_to_use = {}
+            # 2. Generowanie raportu
+            if st.session_state.transcriptions:
+                status_container.info("📄 Generuję raport badawczy...")
+                self.log_message("📄 Rozpoczynam generowanie raportu")
                 
-                # 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)
-                    
                     final_report = self.report_generator.generate_comprehensive_report(
-                        transcriptions_to_use,
-                        research_brief
+                        st.session_state.transcriptions,
+                        st.session_state.research_brief
                     )
                     
-                    # Zapisz raport
-                    try:
-                        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!"
-                    except:
-                        # Fallback - zapisz lokalnie i oznacz flagę
-                        self.local_final_report = final_report
-                        self.processing_completed = True
-                        print("REPORT: Generated and saved locally")
+                    st.session_state.final_report = final_report
+                    st.session_state.processing_status = 'completed'
                     
-                    self.update_progress_safe(1.0, "✅ Zakończono!")
-                    self.log_message("🎉 Raport wygenerowany pomyślnie!", force_local=True)
+                    status_container.success("✅ Przetwarzanie zakończone!")
+                    self.log_message("🎉 Raport wygenerowany pomyślnie!")
                     
-                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:
+                    # Automatyczny refresh żeby pokazać wyniki
+                    st.rerun()
+                    
+                except Exception as e:
+                    self.log_message(f"❌ Błąd generowania raportu: {str(e)}", "ERROR")
+                    st.error(f"Błąd generowania raportu: {str(e)}")
                     st.session_state.processing_status = 'error'
-                except:
-                    print(f"REPORT ERROR: {e}")
+            else:
+                st.session_state.processing_status = 'error'
+                self.log_message("❌ Brak transkrypcji do wygenerowania raportu", "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}")
-        
-        finally:
-            # Oznacz zakończenie przetwarzania
-            self.processing_completed = True
-            print("THREAD: Processing completed - setting flag")
+            self.log_message(f"💥 Błąd krytyczny: {str(e)}", "ERROR")
+            st.error(f"Błąd krytyczny: {str(e)}")
+            st.session_state.processing_status = 'error'
     
     def render_results(self):
         """Renderuj wyniki"""
@@ -663,10 +412,10 @@ class FGIIDIAnalyzer:
                     st.session_state.logs = []
                     st.rerun()
                 
-                # Display logs
-                logs_text = "\n".join(st.session_state.logs)
+                # Display logs - pokazuj najnowsze na górze
+                logs_text = "\n".join(reversed(st.session_state.logs))
                 st.text_area(
-                    "Logi systemu:",
+                    "Logi systemu (najnowsze na górze):",
                     value=logs_text,
                     height=400,
                     disabled=True
@@ -676,36 +425,26 @@ class FGIIDIAnalyzer:
     
     def run(self):
         """Główna funkcja aplikacji"""
-        try:
-            # Sidebar
-            settings = self.render_sidebar()
-            
-            # Main content
-            st.title("🎙️ QualiInsightLab")
-            st.markdown("*Automatyczna transkrypcja i analiza wywiadów fokusowych oraz indywidualnych*")
-            st.markdown("---")
-            
-            # File upload section
-            files_uploaded = self.render_file_upload(settings)
-            
-            st.markdown("---")
-            
-            # Processing section
-            self.render_processing_section(settings)
-            
-            st.markdown("---")
-            
-            # Results section
-            self.render_results()
-            
-        except Exception as e:
-            st.error(f"💥 Błąd aplikacji: {str(e)}")
-            st.code(traceback.format_exc())
-            
-            # Wyczyść sesję przy błędzie
-            if st.button("🔄 Reset po błędzie"):
-                self.cleanup_session()
-                st.rerun()
+        # Sidebar
+        settings = self.render_sidebar()
+        
+        # Main content
+        st.title("🎙️ QualiInsightLab")
+        st.markdown("*Automatyczna transkrypcja i analiza wywiadów fokusowych oraz indywidualnych*")
+        st.markdown("---")
+        
+        # File upload section
+        files_uploaded = self.render_file_upload(settings)
+        
+        st.markdown("---")
+        
+        # Processing section
+        self.render_processing_section(settings)
+        
+        st.markdown("---")
+        
+        # Results section
+        self.render_results()
 
 # Główna aplikacja
 if __name__ == "__main__":
@@ -713,15 +452,11 @@ if __name__ == "__main__":
         app = FGIIDIAnalyzer()
         app.run()
     except Exception as e:
-        st.error(f"💥 Błąd krytyczny: {str(e)}")
+        st.error(f"💥 Błąd aplikacji: {str(e)}")
         st.code(traceback.format_exc())
         
         # Log error for debugging
         with open('error_log.txt', 'w', encoding='utf-8') as f:
             f.write(f"Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
         
-        st.info("Szczegóły błędu zapisane w error_log.txt")
-        
-        # Emergency restart
-        if st.button("🚨 Awaryjny restart"):
-            st.rerun()
+        st.info("Szczegóły błędu zapisane w error_log.txt")