Update app.py

app.py

@@ -4,6 +4,8 @@ import os
 from datetime import datetime
 import time
 import traceback
+import threading
+import queue
 
 # Sprawdzenie zależności
 try:
@@ -75,6 +77,10 @@ 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
     
     def initialize_session_state(self):
         """Inicjalizacja session state"""
@@ -90,6 +96,10 @@ 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"):
         """Dodaj wiadomość do logów"""
@@ -129,15 +139,15 @@ class FGIIDIAnalyzer:
         
         max_file_size = st.sidebar.selectbox(
             "Maksymalny rozmiar części:",
-            [15, 20, 25, 30],
+            [10, 15, 20, 25],
             index=1,
-            help="MB - większe pliki będą dzielone na części"
+            help="MB - większe pliki będą dzielone na części (max 25MB dla Whisper)"
         )
         
         auto_compress = st.sidebar.checkbox(
             "Auto-kompresja dużych plików",
             value=True,
-            help="Automatyczna kompresja plików >50MB"
+            help="Automatyczna kompresja plików >25MB"
         )
         
         language = st.sidebar.selectbox(
@@ -163,8 +173,7 @@ class FGIIDIAnalyzer:
         
         # Reset session
         if st.sidebar.button("🔄 Reset sesji", type="secondary"):
-            for key in list(st.session_state.keys()):
-                del st.session_state[key]
+            self.cleanup_session()
             st.rerun()
         
         return {
@@ -174,6 +183,21 @@ class FGIIDIAnalyzer:
             'language': language
         }
     
+    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'
+        
+        # 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()
+    
     def render_file_upload(self, settings):
         """Renderuj sekcję upload plików"""
         st.header("📁 Upload plików audio/video")
@@ -194,7 +218,7 @@ class FGIIDIAnalyzer:
             "Wybierz pliki audio/video:",
             type=['mp3', 'wav', 'mp4', 'm4a', 'aac'],
             accept_multiple_files=True,
-            help="Obsługiwane formaty: MP3, WAV, MP4, M4A, AAC"
+            help="Obsługiwane formaty: MP3, WAV, MP4, M4A, AAC (max 25MB każdy dla Whisper)"
         )
         
         if uploaded_files:
@@ -207,15 +231,16 @@ class FGIIDIAnalyzer:
                 total_size += file_size_mb
                 
                 # Sprawdź rozmiar pojedynczego pliku
-                if file_size_mb > 200:  # 200MB limit dla pojedynczego pliku
-                    st.error(f"❌ {file.name}: Plik za duży ({file_size_mb:.1f}MB). Maksymalnie 200MB.")
+                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
                 
                 valid_files.append({
                     'file': file,
                     'name': file.name,
                     'size_mb': file_size_mb,
-                    'needs_splitting': file_size_mb > settings['max_file_size']
+                    'needs_splitting': file_size_mb > settings['max_file_size'],
+                    'needs_compression': file_size_mb > 25  # Whisper limit
                 })
             
             # Wyświetl informacje o plikach
@@ -233,7 +258,9 @@ class FGIIDIAnalyzer:
                         st.write(f"{file_info['size_mb']:.1f}MB")
                     
                     with col3:
-                        if file_info['needs_splitting']:
+                        if file_info['needs_compression']:
+                            st.error("Wymaga kompresji")
+                        elif file_info['needs_splitting']:
                             st.warning("Będzie podzielony")
                         else:
                             st.success("OK")
@@ -255,18 +282,55 @@ class FGIIDIAnalyzer:
         
         st.header("🚀 Przetwarzanie")
         
-        # Przycisk start
+        # 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
         if st.session_state.processing_status == 'ready':
             if st.button("🎯 Rozpocznij transkrypcję i analizę", type="primary"):
                 st.session_state.processing_status = 'running'
-                self.process_files(settings)
+                st.session_state.current_file_progress = ""
+                st.session_state.overall_progress = 0
+                
+                # Uruchom przetwarzanie w osobnym wątku
+                self.processing_thread = threading.Thread(
+                    target=self.process_files_async,
+                    args=(settings,)
+                )
+                self.processing_thread.start()
+                st.rerun()
         
         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 zatrzymane")
+                st.warning("Przetwarzanie zostanie zatrzymane...")
+                st.rerun()
+        
+        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.rerun()
+        
+        elif st.session_state.processing_status == 'error':
+            st.error("❌ Przetwarzanie zakończone błędem")
+            
+            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':
@@ -277,65 +341,84 @@ class FGIIDIAnalyzer:
         progress_container = st.container()
         
         with progress_container:
-            # Overall progress
+            # 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")
             
-            progress = completed_files / total_files if total_files > 0 else 0
-            st.progress(progress)
-            st.write(f"📊 Postęp ogólny: {completed_files}/{total_files} plików")
-            
-            # Current file info
-            if completed_files < total_files:
-                current_file = st.session_state.uploaded_files[completed_files]['name']
-                st.write(f"🔄 Aktualnie: {current_file}")
+            # Auto-refresh podczas przetwarzania
+            if st.session_state.processing_status == 'running':
+                time.sleep(2)
+                st.rerun()
     
-    def process_files(self, settings):
-        """Główna logika przetwarzania plików"""
+    def process_files_async(self, settings):
+        """Asynchroniczne przetwarzanie plików"""
         try:
-            self.log_message("Rozpoczynam przetwarzanie plików")
+            self.log_message("🚀 Rozpoczynam przetwarzanie plików")
             
-            # Container dla live updates
-            status_container = st.empty()
-            progress_container = st.empty()
+            total_files = len(st.session_state.uploaded_files)
             
-            # 1. Transkrypcja wszystkich plików
+            # 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
                 
-                status_container.info(f"🎙️ Transkrybuję: {file_info['name']}")
-                self.log_message(f"Rozpoczynam transkrypcję: {file_info['name']}")
-                
                 try:
-                    # Przetwórz plik (podział jeśli potrzeba)
+                    # 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.log_message(f"📝 Rozpoczynam transkrypcję: {file_info['name']}")
+                    
+                    # Przetwórz plik (kompresja/podział jeśli potrzeba)
                     processed_files = self.file_handler.process_file(
                         file_info['file'], 
                         settings['max_file_size'],
                         settings['auto_compress']
                     )
                     
-                    # Transkrypcja
-                    transcription = self.transcriber.transcribe_files(
-                        processed_files,
-                        language=settings['language']
-                    )
+                    if not processed_files:
+                        raise Exception("Nie udało się przetworzyć pliku")
                     
-                    st.session_state.transcriptions[file_info['name']] = transcription
-                    self.log_message(f"✅ Zakończono transkrypcję: {file_info['name']}")
+                    # Sprawdź rozmiary przed wysłaniem do Whisper
+                    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 dla Whisper: {file_size_mb:.1f}MB", "ERROR")
+                            continue
                     
-                    # Update progress
-                    progress = (i + 1) / len(st.session_state.uploaded_files)
-                    progress_container.progress(progress)
+                    # Transkrypcja z retry logic
+                    transcription = self.transcriber.transcribe_with_retries(
+                        processed_files[0] if len(processed_files) == 1 else processed_files,
+                        language=settings['language'],
+                        max_retries=3
+                    )
                     
+                    if transcription:
+                        st.session_state.transcriptions[file_info['name']] = transcription
+                        self.log_message(f"✅ Transkrypcja zakończona: {file_info['name']}")
+                    else:
+                        self.log_message(f"❌ Transkrypcja nieudana: {file_info['name']}", "ERROR")
+                        
                 except Exception as e:
-                    self.log_message(f"❌ Błąd transkrypcji {file_info['name']}: {str(e)}", "ERROR")
-                    st.error(f"Błąd przy {file_info['name']}: {str(e)}")
+                    self.log_message(f"❌ Błąd przetwarzania {file_info['name']}: {str(e)}", "ERROR")
+                    continue
             
-            # 2. Generowanie raportu
+            # ETAP 2: Generowanie raportu
             if st.session_state.transcriptions and st.session_state.processing_status == 'running':
-                status_container.info("📄 Generuję raport badawczy...")
-                self.log_message("Rozpoczynam generowanie raportu")
+                st.session_state.current_file_progress = "📄 Generuję raport badawczy..."
+                st.session_state.overall_progress = 0.9
+                
+                self.log_message("📄 Rozpoczynam generowanie raportu")
                 
                 try:
                     final_report = self.report_generator.generate_comprehensive_report(
@@ -345,18 +428,22 @@ class FGIIDIAnalyzer:
                     
                     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!"
                     
-                    status_container.success("✅ Przetwarzanie zakończone!")
-                    self.log_message("✅ Raport wygenerowany pomyślnie")
+                    self.log_message("🎉 Raport wygenerowany pomyślnie!")
                     
                 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'
             
+            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")
-            st.error(f"Błąd krytyczny: {str(e)}")
             st.session_state.processing_status = 'error'
     
     def render_results(self):
@@ -411,14 +498,15 @@ class FGIIDIAnalyzer:
             st.subheader("📋 Logi procesu")
             
             if st.session_state.logs:
-                # Scroll to bottom option
-                if st.button("⬇️ Przewiń na dół"):
-                    pass  # Auto-scroll jest w CSS
+                # Clear logs button
+                if st.button("🧹 Wyczyść logi"):
+                    st.session_state.logs = []
+                    st.rerun()
                 
                 # Display logs
                 logs_text = "\n".join(st.session_state.logs)
                 st.text_area(
-                    "Logi:",
+                    "Logi systemu:",
                     value=logs_text,
                     height=400,
                     disabled=True
@@ -428,26 +516,36 @@ class FGIIDIAnalyzer:
     
     def run(self):
         """Główna funkcja aplikacji"""
-        # Sidebar
-        settings = self.render_sidebar()
-        
-        # Main content
-        st.title("🎙️ FGI/IDI Research Analyzer")
-        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()
+        try:
+            # Sidebar
+            settings = self.render_sidebar()
+            
+            # Main content
+            st.title("🎙️ FGI/IDI Research Analyzer")
+            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()
 
 # Główna aplikacja
 if __name__ == "__main__":
@@ -455,11 +553,15 @@ if __name__ == "__main__":
         app = FGIIDIAnalyzer()
         app.run()
     except Exception as e:
-        st.error(f"💥 Błąd aplikacji: {str(e)}")
+        st.error(f"💥 Błąd krytyczny: {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")
+        st.info("Szczegóły błędu zapisane w error_log.txt")
+        
+        # Emergency restart
+        if st.button("🚨 Awaryjny restart"):
+            st.experimental_rerun()