Update file_handler.py

file_handler.py

@@ -1,4 +1,4 @@
-# file_handler.py - Obsługa plików audio/video dla HuggingFace
+# file_handler.py - Poprawiony handler plików dla Whisper API
 
 import os
 import tempfile
@@ -12,7 +12,7 @@ try:
     PYDUB_AVAILABLE = True
 except ImportError:
     PYDUB_AVAILABLE = False
-    st.warning("⚠️ Pydub nie jest dostępny. Zainstaluj: pip install pydub")
+    st.warning("⚠️ Pydub nie jest dostępny. Funkcje kompresji ograniczone.")
 
 try:
     import librosa
@@ -24,86 +24,124 @@ except ImportError:
 from config import FILE_PROCESSING, USER_MESSAGES
 
 class FileHandler:
-    """Klasa do obsługi plików audio/video - optymalizowana dla HuggingFace"""
+    """Klasa do obsługi plików audio/video - zoptymalizowana dla Whisper API (max 25MB)"""
     
     def __init__(self):
-        self.temp_files = []  # Lista plików tymczasowych do wyczyszczenia
+        self.temp_files = []
         self.processing_stats = {}
         
-    def process_file(self, uploaded_file, max_chunk_size_mb: int = 15, auto_compress: bool = True) -> List[str]:
+        # Whisper API limits
+        self.WHISPER_MAX_SIZE_MB = 25
+        self.SAFE_CHUNK_SIZE_MB = 20  # Bezpieczny rozmiar chunka
+        
+    def process_file(self, uploaded_file, max_chunk_size_mb: int = 20, auto_compress: bool = True) -> List[str]:
         """
-        Główna funkcja przetwarzania pliku
-        Returns: Lista ścieżek do plików gotowych do transkrypcji
+        Główna funkcja przetwarzania pliku dla Whisper API
+        Returns: Lista ścieżek do plików gotowych do transkrypcji (każdy <25MB)
         """
         try:
             file_size_mb = uploaded_file.size / (1024 * 1024)
             
-            # Loguj rozpoczęcie przetwarzania
             st.info(f"🔄 Przetwarzam {uploaded_file.name} ({file_size_mb:.1f}MB)")
             
-            # Sprawdź czy plik wymaga kompresji
-            if file_size_mb > 50 and auto_compress:
-                compressed_file = self._compress_audio(uploaded_file)
+            # Sprawdź czy plik mieści się w limicie Whisper
+            if file_size_mb <= self.WHISPER_MAX_SIZE_MB:
+                # Plik OK - zapisz bezpośrednio
+                temp_path = self._save_temp_file(uploaded_file)
+                if temp_path:
+                    st.success(f"✅ Plik gotowy do transkrypcji ({file_size_mb:.1f}MB)")
+                    return [temp_path]
+                else:
+                    return []
+            
+            # Plik za duży - wymaga przetwarzania
+            if file_size_mb > 100:
+                st.error(f"❌ Plik zbyt duży ({file_size_mb:.1f}MB). Maksymalnie 100MB.")
+                return []
+            
+            # Strategia 1: Kompresja
+            if auto_compress and file_size_mb > self.WHISPER_MAX_SIZE_MB:
+                compressed_file = self._compress_audio_for_whisper(uploaded_file)
                 if compressed_file:
-                    uploaded_file = compressed_file
-                    file_size_mb = compressed_file.size / (1024 * 1024)
-                    st.success(f"✅ Skompresowano do {file_size_mb:.1f}MB")
+                    compressed_size_mb = len(compressed_file.getvalue()) / (1024 * 1024)
+                    if compressed_size_mb <= self.WHISPER_MAX_SIZE_MB:
+                        temp_path = self._save_bytesio_to_temp(compressed_file, uploaded_file.name)
+                        if temp_path:
+                            st.success(f"✅ Skompresowano: {file_size_mb:.1f}MB → {compressed_size_mb:.1f}MB")
+                            return [temp_path]
             
-            # Sprawdź czy plik wymaga dzielenia
-            if file_size_mb > max_chunk_size_mb:
-                return self._split_audio_file(uploaded_file, max_chunk_size_mb)
-            else:
-                # Plik nie wymaga dzielenia - zapisz bezpośrednio
-                temp_path = self._save_temp_file(uploaded_file)
-                return [temp_path]
+            # Strategia 2: Podział na części
+            return self._split_audio_for_whisper(uploaded_file, max_chunk_size_mb)
                 
         except Exception as e:
             st.error(f"❌ Błąd przetwarzania {uploaded_file.name}: {str(e)}")
             return []
     
-    def _compress_audio(self, uploaded_file) -> Union[BytesIO, None]:
-        """Kompresja pliku audio używając pydub"""
+    def _compress_audio_for_whisper(self, uploaded_file) -> Union[BytesIO, None]:
+        """Agresywna kompresja audio dla Whisper API"""
         if not PYDUB_AVAILABLE:
             st.warning("Pydub niedostępny - pomijam kompresję")
             return None
             
         try:
+            st.info("🗜️ Kompresuję audio...")
+            
             # Załaduj audio
             audio_data = uploaded_file.read()
+            uploaded_file.seek(0)  # Reset dla dalszego użycia
+            
             audio = AudioSegment.from_file(BytesIO(audio_data))
             
-            # Kompresja: mono, lower bitrate, lower sample rate
+            # Agresywna kompresja dla Whisper (jakość mowy)
             compressed = audio.set_channels(1)  # Mono
             compressed = compressed.set_frame_rate(16000)  # 16kHz (wystarczy dla mowy)
             
+            # Jeszcze więcej kompresji jeśli potrzeba
+            original_size_mb = uploaded_file.size / (1024 * 1024)
+            
+            if original_size_mb > 50:
+                # Bardzo duży plik - maksymalna kompresja
+                bitrate = "32k"
+            elif original_size_mb > 35:
+                # Duży plik - silna kompresja
+                bitrate = "48k"
+            else:
+                # Średni plik - umiarkowana kompresja
+                bitrate = "64k"
+            
             # Export do BytesIO
             output = BytesIO()
             compressed.export(
                 output, 
                 format="mp3", 
-                bitrate="64k",  # Niska jakość dla kompresji
-                parameters=["-ac", "1"]  # Force mono
+                bitrate=bitrate,
+                parameters=["-ac", "1", "-ar", "16000"]
             )
             output.seek(0)
             
-            # Stwórz nowy "uploaded file" object
-            output.name = uploaded_file.name.replace('.', '_compressed.')
-            output.size = len(output.getvalue())
+            # Sprawdź rozmiar wyniku
+            compressed_size_mb = len(output.getvalue()) / (1024 * 1024)
             
-            return output
+            if compressed_size_mb <= self.WHISPER_MAX_SIZE_MB:
+                return output
+            else:
+                st.warning(f"⚠️ Kompresja niewystarczająca ({compressed_size_mb:.1f}MB). Przechodzę do dzielenia.")
+                return None
             
         except Exception as e:
             st.warning(f"Kompresja nieudana: {str(e)}")
             return None
     
-    def _split_audio_file(self, uploaded_file, max_chunk_size_mb: int) -> List[str]:
-        """Dzieli plik audio na mniejsze części"""
+    def _split_audio_for_whisper(self, uploaded_file, max_chunk_size_mb: int) -> List[str]:
+        """Dzieli plik audio na części <25MB dla Whisper"""
         try:
             if not PYDUB_AVAILABLE:
                 st.error("❌ Pydub wymagany do dzielenia plików. Zainstaluj: pip install pydub")
                 return []
             
-            # Załaduj cały plik audio
+            st.info("✂️ Dzielę plik na części...")
+            
+            # Załaduj audio
             audio_data = uploaded_file.read()
             audio = AudioSegment.from_file(BytesIO(audio_data))
             
@@ -111,12 +149,15 @@ class FileHandler:
             total_duration_ms = len(audio)
             file_size_mb = uploaded_file.size / (1024 * 1024)
             
-            # Estymacja liczby części na podstawie rozmiaru
-            estimated_parts = math.ceil(file_size_mb / max_chunk_size_mb)
+            # Bezpieczny rozmiar chunka (mniejszy niż limit Whisper)
+            safe_chunk_size_mb = min(max_chunk_size_mb, self.SAFE_CHUNK_SIZE_MB)
+            
+            # Estymacja liczby części
+            estimated_parts = math.ceil(file_size_mb / safe_chunk_size_mb)
             chunk_duration_ms = total_duration_ms // estimated_parts
             
-            # Dodaj overlap między częściami (30 sekund)
-            overlap_ms = 5 * 1000
+            # Overlap między częściami (10 sekund)
+            overlap_ms = 10 * 1000
             
             st.info(f"📂 Dzielę na {estimated_parts} części (~{chunk_duration_ms//60000:.1f} min każda)")
             
@@ -124,22 +165,41 @@ class FileHandler:
             base_name = os.path.splitext(uploaded_file.name)[0]
             
             for i in range(estimated_parts):
-                start_ms = max(0, i * chunk_duration_ms - overlap_ms if i > 0 else 0)
+                start_ms = max(0, i * chunk_duration_ms - (overlap_ms if i > 0 else 0))
                 end_ms = min(total_duration_ms, (i + 1) * chunk_duration_ms + overlap_ms)
                 
                 # Wytnij część
                 chunk = audio[start_ms:end_ms]
                 
+                # Lekka kompresja części
+                chunk = chunk.set_channels(1)  # Mono
+                chunk = chunk.set_frame_rate(22050)  # Dobra jakość ale kompaktowa
+                
                 # Zapisz do pliku tymczasowego
-                temp_fd, temp_path = tempfile.mkstemp(suffix=f"_part{i+1:02d}.mp3", prefix=f"{base_name}_")
+                temp_fd, temp_path = tempfile.mkstemp(
+                    suffix=f"_part{i+1:02d}.mp3", 
+                    prefix=f"{base_name}_"
+                )
                 os.close(temp_fd)
                 
-                chunk.export(temp_path, format="mp3", bitrate="128k")
+                chunk.export(temp_path, format="mp3", bitrate="96k")
+                
+                # Sprawdź rozmiar części
+                part_size_mb = os.path.getsize(temp_path) / (1024 * 1024)
+                
+                if part_size_mb > self.WHISPER_MAX_SIZE_MB:
+                    st.error(f"❌ Część {i+1} nadal za duża ({part_size_mb:.1f}MB)")
+                    os.remove(temp_path)
+                    continue
+                
                 parts.append(temp_path)
                 self.temp_files.append(temp_path)
                 
-                st.success(f"✅ Część {i+1}/{estimated_parts}: {(end_ms-start_ms)//60000:.1f} min")
+                st.success(f"✅ Część {i+1}/{estimated_parts}: {part_size_mb:.1f}MB, {(end_ms-start_ms)//60000:.1f} min")
             
+            if not parts:
+                st.error("❌ Nie udało się utworzyć żadnej prawidłowej części")
+                
             return parts
             
         except Exception as e:
@@ -149,13 +209,16 @@ class FileHandler:
     def _save_temp_file(self, uploaded_file) -> str:
         """Zapisuje uploaded file do pliku tymczasowego"""
         try:
-            # Stwórz plik tymczasowy
             suffix = f".{uploaded_file.name.split('.')[-1]}"
             temp_fd, temp_path = tempfile.mkstemp(suffix=suffix)
             
             # Zapisz dane
             with os.fdopen(temp_fd, 'wb') as tmp_file:
-                tmp_file.write(uploaded_file.read())
+                content = uploaded_file.read()
+                tmp_file.write(content)
+            
+            # Reset pozycji dla dalszego użycia
+            uploaded_file.seek(0)
             
             self.temp_files.append(temp_path)
             return temp_path
@@ -164,73 +227,103 @@ class FileHandler:
             st.error(f"❌ Błąd zapisu tymczasowego: {str(e)}")
             return ""
     
-    def get_audio_duration(self, file_path: str) -> float:
-        """Pobierz długość pliku audio w sekundach"""
+    def _save_bytesio_to_temp(self, bytes_io: BytesIO, original_name: str) -> str:
+        """Zapisz BytesIO do pliku tymczasowego"""
         try:
-            if LIBROSA_AVAILABLE:
-                duration = librosa.get_duration(filename=file_path)
-                return duration
-            elif PYDUB_AVAILABLE:
-                audio = AudioSegment.from_file(file_path)
-                return len(audio) / 1000.0  # Convert ms to seconds
-            else:
-                # Fallback - estymacja na podstawie rozmiaru
-                file_size = os.path.getsize(file_path)
-                # Przybliżenie: 1MB ≈ 60 sekund dla typowego audio MP3
-                return file_size / (1024 * 1024) * 60
-        except:
-            # Ostateczny fallback
-            file_size = os.path.getsize(file_path)
-            return file_size / (1024 * 1024) * 60
+            suffix = f"_compressed.mp3"
+            base_name = os.path.splitext(original_name)[0]
+            
+            temp_fd, temp_path = tempfile.mkstemp(
+                suffix=suffix,
+                prefix=f"{base_name}_"
+            )
+            
+            with os.fdopen(temp_fd, 'wb') as tmp_file:
+                tmp_file.write(bytes_io.getvalue())
+            
+            self.temp_files.append(temp_path)
+            return temp_path
+            
+        except Exception as e:
+            st.error(f"❌ Błąd zapisu skompresowanego: {str(e)}")
+            return ""
     
-    def validate_file(self, uploaded_file) -> Tuple[bool, str]:
-        """Walidacja pliku audio/video"""
+    def validate_file_for_whisper(self, uploaded_file) -> Tuple[bool, str]:
+        """Walidacja pliku dla Whisper API"""
         try:
             # Sprawdź rozmiar
             file_size_mb = uploaded_file.size / (1024 * 1024)
-            if file_size_mb > FILE_PROCESSING['max_single_file_mb']:
-                return False, f"Plik za duży: {file_size_mb:.1f}MB > {FILE_PROCESSING['max_single_file_mb']}MB"
+            
+            if file_size_mb == 0:
+                return False, "Plik jest pusty"
+            
+            if file_size_mb > 100:  # Rozumny limit dla przetwarzania
+                return False, f"Plik za duży: {file_size_mb:.1f}MB > 100MB"
             
             # Sprawdź rozszerzenie
             file_ext = uploaded_file.name.split('.')[-1].lower()
-            supported_formats = (
-                FILE_PROCESSING['supported_audio_formats'] + 
-                FILE_PROCESSING['supported_video_formats']
-            )
+            supported_formats = ['mp3', 'wav', 'mp4', 'm4a', 'aac', 'mov', 'avi']
             
             if file_ext not in supported_formats:
                 return False, f"Nieobsługiwany format: .{file_ext}"
             
-            # Sprawdź czy plik nie jest pusty
-            if uploaded_file.size == 0:
-                return False, "Plik jest pusty"
+            # Ostrzeżenie dla dużych plików
+            if file_size_mb > self.WHISPER_MAX_SIZE_MB:
+                return True, f"Plik wymaga przetwarzania ({file_size_mb:.1f}MB > {self.WHISPER_MAX_SIZE_MB}MB)"
             
             return True, "OK"
             
         except Exception as e:
             return False, f"Błąd walidacji: {str(e)}"
     
+    def get_audio_duration(self, file_path: str) -> float:
+        """Pobierz długość pliku audio w sekundach"""
+        try:
+            if LIBROSA_AVAILABLE:
+                duration = librosa.get_duration(filename=file_path)
+                return duration
+            elif PYDUB_AVAILABLE:
+                audio = AudioSegment.from_file(file_path)
+                return len(audio) / 1000.0
+            else:
+                # Fallback - estymacja na podstawie rozmiaru
+                file_size = os.path.getsize(file_path)
+                return file_size / (1024 * 1024) * 60
+        except:
+            file_size = os.path.getsize(file_path)
+            return file_size / (1024 * 1024) * 60
+    
     def estimate_processing_time(self, uploaded_files: List) -> Dict:
         """Estymuj czas przetwarzania"""
         total_size_mb = sum(f.size for f in uploaded_files) / (1024 * 1024)
-        total_duration_est = total_size_mb * 60  # 1MB ≈ 60s audio
+        total_duration_est = total_size_mb * 60
+        
+        # Czas przetwarzania (kompresja/dzielenie)
+        processing_time = 0
+        for f in uploaded_files:
+            file_size_mb = f.size / (1024 * 1024)
+            if file_size_mb > self.WHISPER_MAX_SIZE_MB:
+                processing_time += file_size_mb * 2  # ~2s per MB for processing
         
         # Estymacja czasu transkrypcji (Whisper ~1:10 ratio)
-        transcription_time = total_duration_est * 1.1
+        transcription_time = total_duration_est * 0.1
         
-        # Estymacja czasu generowania raportu (zależnie od liczby wywiadów)
-        report_time = len(uploaded_files) * 30  # ~30s per interview dla raportu
+        # Estymacja czasu generowania raportu
+        report_time = len(uploaded_files) * 30
         
         return {
             'total_size_mb': total_size_mb,
             'estimated_audio_duration': total_duration_est,
+            'estimated_processing_time': processing_time,
             'estimated_transcription_time': transcription_time,
             'estimated_report_time': report_time,
-            'total_estimated_time': transcription_time + report_time
+            'total_estimated_time': processing_time + transcription_time + report_time,
+            'files_needing_processing': sum(1 for f in uploaded_files 
+                                          if f.size / (1024 * 1024) > self.WHISPER_MAX_SIZE_MB)
         }
     
     def get_file_info(self, uploaded_file) -> Dict:
-        """Pobierz informacje o pliku"""
+        """Pobierz szczegółowe informacje o pliku"""
         file_size_mb = uploaded_file.size / (1024 * 1024)
         file_ext = uploaded_file.name.split('.')[-1].lower()
         
@@ -238,40 +331,161 @@ class FileHandler:
             'name': uploaded_file.name,
             'size_mb': file_size_mb,
             'format': file_ext,
-            'needs_compression': file_size_mb > 50,
-            'needs_splitting': file_size_mb > 20,
-            'estimated_duration': file_size_mb * 60  # Rough estimate
+            'whisper_ready': file_size_mb <= self.WHISPER_MAX_SIZE_MB,
+            'needs_compression': file_size_mb > self.WHISPER_MAX_SIZE_MB and file_size_mb <= 50,
+            'needs_splitting': file_size_mb > 50,
+            'too_large': file_size_mb > 100,
+            'estimated_duration': file_size_mb * 60,
+            'estimated_processing_time': max(0, file_size_mb - self.WHISPER_MAX_SIZE_MB) * 2
         }
     
     def cleanup_temp_files(self):
         """Wyczyść pliki tymczasowe"""
         cleaned = 0
+        errors = 0
+        
         for temp_file in self.temp_files:
             try:
                 if os.path.exists(temp_file):
                     os.remove(temp_file)
                     cleaned += 1
             except Exception as e:
+                errors += 1
                 st.warning(f"Nie można usunąć {temp_file}: {e}")
         
         self.temp_files = []
+        
         if cleaned > 0:
             st.success(f"🧹 Wyczyszczono {cleaned} plików tymczasowych")
+        
+        if errors > 0:
+            st.warning(f"⚠️ {errors} plików nie udało się usunąć")
     
     def get_processing_stats(self) -> Dict:
         """Zwróć statystyki przetwarzania"""
         return {
             'temp_files_count': len(self.temp_files),
+            'whisper_max_size_mb': self.WHISPER_MAX_SIZE_MB,
+            'safe_chunk_size_mb': self.SAFE_CHUNK_SIZE_MB,
             'processing_stats': self.processing_stats,
             'libraries_available': {
                 'pydub': PYDUB_AVAILABLE,
                 'librosa': LIBROSA_AVAILABLE
             }
         }
+    
+    def analyze_upload_batch(self, uploaded_files: List) -> Dict:
+        """Analizuj całą paczkę plików"""
+        analysis = {
+            'total_files': len(uploaded_files),
+            'total_size_mb': 0,
+            'whisper_ready': 0,
+            'need_compression': 0,
+            'need_splitting': 0,
+            'too_large': 0,
+            'estimated_parts': 0,
+            'file_details': []
+        }
+        
+        for file in uploaded_files:
+            info = self.get_file_info(file)
+            analysis['file_details'].append(info)
+            analysis['total_size_mb'] += info['size_mb']
+            
+            if info['whisper_ready']:
+                analysis['whisper_ready'] += 1
+            elif info['needs_compression']:
+                analysis['need_compression'] += 1
+            elif info['needs_splitting']:
+                analysis['need_splitting'] += 1
+                # Estymacja liczby części
+                parts = math.ceil(info['size_mb'] / self.SAFE_CHUNK_SIZE_MB)
+                analysis['estimated_parts'] += parts
+            elif info['too_large']:
+                analysis['too_large'] += 1
+        
+        return analysis
+    
+    def create_processing_plan(self, uploaded_files: List) -> str:
+        """Stwórz plan przetwarzania dla użytkownika"""
+        analysis = self.analyze_upload_batch(uploaded_files)
+        
+        plan = f"""
+📋 **PLAN PRZETWARZANIA**
+
+📊 **Podsumowanie:**
+- Plików: {analysis['total_files']} ({analysis['total_size_mb']:.1f}MB)
+- Gotowych do transkrypcji: {analysis['whisper_ready']}
+- Wymagających kompresji: {analysis['need_compression']}
+- Wymagających dzielenia: {analysis['need_splitting']}
+- Za dużych: {analysis['too_large']}
 
-# Test funkcji
+"""
+        
+        if analysis['estimated_parts'] > 0:
+            plan += f"- Szacowana liczba części: {analysis['estimated_parts']}\n"
+        
+        if analysis['too_large'] > 0:
+            plan += f"\n❌ **PLIKI ZA DUŻE (>100MB):**\n"
+            for info in analysis['file_details']:
+                if info['too_large']:
+                    plan += f"- {info['name']}: {info['size_mb']:.1f}MB\n"
+        
+        if analysis['need_splitting'] > 0:
+            plan += f"\n✂️ **PLIKI DO PODZIELENIA:**\n"
+            for info in analysis['file_details']:
+                if info['needs_splitting']:
+                    parts = math.ceil(info['size_mb'] / self.SAFE_CHUNK_SIZE_MB)
+                    plan += f"- {info['name']}: {info['size_mb']:.1f}MB → ~{parts} części\n"
+        
+        if analysis['need_compression'] > 0:
+            plan += f"\n🗜️ **PLIKI DO KOMPRESJI:**\n"
+            for info in analysis['file_details']:
+                if info['needs_compression']:
+                    plan += f"- {info['name']}: {info['size_mb']:.1f}MB\n"
+        
+        # Estymacja czasów
+        times = self.estimate_processing_time(uploaded_files)
+        plan += f"""
+⏱️ **ESTYMACJA CZASÓW:**
+- Przetwarzanie plików: ~{times['estimated_processing_time']:.1f}s
+- Transkrypcja: ~{times['estimated_transcription_time']:.1f}s
+- Generowanie raportu: ~{times['estimated_report_time']:.1f}s
+- **ŁĄCZNIE: ~{times['total_estimated_time']:.1f}s ({times['total_estimated_time']/60:.1f} min)**
+"""
+        
+        return plan
+
+# Funkcje pomocnicze
+def check_file_size_for_whisper(file_path: str) -> Tuple[bool, float]:
+    """Sprawdź czy plik mieści się w limicie Whisper"""
+    try:
+        size_mb = os.path.getsize(file_path) / (1024 * 1024)
+        return size_mb <= 25, size_mb
+    except:
+        return False, 0
+
+def estimate_compression_ratio(file_ext: str) -> float:
+    """Estymuj współczynnik kompresji dla różnych formatów"""
+    ratios = {
+        'wav': 0.1,    # WAV kompresuje się bardzo dobrze
+        'aac': 0.7,    # AAC już skompresowany
+        'mp3': 0.8,    # MP3 już skompresowany
+        'm4a': 0.7,    # M4A już skompresowany
+        'mp4': 0.5,    # Video można mocno skompresować audio
+        'mov': 0.5,
+        'avi': 0.4
+    }
+    return ratios.get(file_ext.lower(), 0.6)
+
+# Test modułu
 if __name__ == "__main__":
     print("🧪 Test FileHandler")
     handler = FileHandler()
-    print(f"📊 Dostępne biblioteki: {handler.get_processing_stats()['libraries_available']}")
+    
+    stats = handler.get_processing_stats()
+    print(f"📊 Biblioteki: {stats['libraries_available']}")
+    print(f"🎯 Limit Whisper: {stats['whisper_max_size_mb']}MB")
+    print(f"🔒 Bezpieczny chunk: {stats['safe_chunk_size_mb']}MB")
+    
     print("✅ FileHandler gotowy do użycia")