Update app.py

app.py

@@ -19,6 +19,7 @@ class TranscriptionService:
     """Klasa do zarządzania modelami ASR na różnych urządzeniach."""
 
     def __init__(self):
+        # Usunięcie wstępnego ładowania. Modele będą ładowane dynamicznie
         self.models = {
             'mps': None,
             'cuda': None,
@@ -31,25 +32,15 @@ class TranscriptionService:
     def _get_optimal_device(self, audio_length_minutes: float) -> str:
         """
         Wybiera optymalne urządzenie na podstawie długości audio i dostępności sprzętu.
-        
-        Args:
-            audio_length_minutes: Długość audio w minutach
-            
-        Returns:
-            str: Nazwa urządzenia ('mps', 'cuda' lub 'cpu')
         """
-        # Sprawdź CUDA jako pierwszy wybór dla wszystkich długości
         if torch.cuda.is_available():
             logger.info("Używam CUDA (GPU) - najlepsza wydajność")
             return "cuda"
             
-        
-        # MPS tylko dla krótszych plików
         if torch.backends.mps.is_available() and audio_length_minutes <= 8:
             logger.info(f"Plik krótki ({audio_length_minutes:.2f} min) - używam MPS")
             return "mps"
         
-        # CPU jako fallback
         if torch.backends.mps.is_available() and audio_length_minutes > 8:
             logger.info(f"Plik długi ({audio_length_minutes:.2f} min) - używam CPU zamiast MPS")
         else:
@@ -60,12 +51,6 @@ class TranscriptionService:
     def _load_model(self, device: str) -> nemo_asr.models.ASRModel:
         """
         Ładuje model na określonym urządzeniu (z cache'owaniem).
-        
-        Args:
-            device: Urządzenie docelowe
-            
-        Returns:
-            Załadowany model ASR
         """
         if self.models[device] is None:
             logger.info(f"Ładowanie modelu na {device.upper()}...")
@@ -84,13 +69,6 @@ class TranscriptionService:
     def _split_audio(self, audio_file_path: str, chunk_length_ms: int) -> list:
         """
         Dzieli długi plik audio na mniejsze fragmenty.
-
-        Args:
-            audio_file_path: Ścieżka do pliku audio
-            chunk_length_ms: Długość fragmentu w milisekundach
-
-        Returns:
-            list: Lista ścieżek do plików tymczasowych
         """
         audio = AudioSegment.from_file(audio_file_path)
         chunks = []
@@ -105,19 +83,14 @@ class TranscriptionService:
     def _transcribe_with_timeout(self, audio_file_path: str, device: str) -> str:
         """
         Wykonuje transkrypcję z timeoutem.
-
-        Args:
-            audio_file_path: Ścieżka do pliku audio
-            device: Urządzenie do transkrypcji
-
-        Returns:
-            str: Transkrypcja
         """
+        # Ładowanie modelu przeniesione tutaj
+        model = self._load_model(device)
+        
         result = {"text": None, "error": None}
 
         def transcribe_worker():
             try:
-                model = self._load_model(device)
                 transcriptions = model.transcribe([audio_file_path])
                 if transcriptions and len(transcriptions) > 0:
                     result["text"] = transcriptions[0].text
@@ -141,31 +114,20 @@ class TranscriptionService:
     def transcribe(self, audio_file_path: str, progress=None) -> str:
         """
         Główna funkcja transkrypcji.
-
-        Args:
-            audio_file_path: Ścieżka do pliku audio
-            progress: Obiekt progress Gradio (opcjonalnie)
-
-        Returns:
-            str: Transkrypcja lub komunikat błędu
         """
-        # Walidacja pliku
         if not audio_file_path or not os.path.exists(audio_file_path):
             return "Błąd: Nie wybrano pliku audio lub plik nie istnieje."
 
         temp_files = []
 
         try:
-            # Analiza długości pliku
             logger.info(f"Analizuję plik: {os.path.basename(audio_file_path)}")
             audio = AudioSegment.from_file(audio_file_path)
             length_minutes = len(audio) / (1000 * 60)
             logger.info(f"Długość pliku: {length_minutes:.2f} minut")
 
-            # Wybór optymalnego urządzenia
             device = self._get_optimal_device(length_minutes)
 
-            # Dziel długie pliki na fragmenty
             if length_minutes > self.chunk_length_minutes:
                 if progress:
                     progress(0.1, desc="Dzielę plik na fragmenty...")
@@ -190,7 +152,6 @@ class TranscriptionService:
 
                 result_text = " ".join(all_transcriptions)
             else:
-                # Krótkie pliki - transkrypcja całości
                 if progress:
                     progress(0.5, desc="Rozpoczynam transkrypcję...")
 
@@ -213,7 +174,6 @@ class TranscriptionService:
             logger.error(error_msg)
             return error_msg
         finally:
-            # Sprzątanie plików tymczasowych
             for temp_file in temp_files:
                 try:
                     os.remove(temp_file)
@@ -248,12 +208,13 @@ def create_interface() -> gr.Interface:
         **Obsługiwane formaty:** WAV, MP3, FLAC, M4A i inne
         **Optymalizacja urządzenia:** Automatyczny wybór GPU/CPU
         """,
+        examples=None,
+        cache_examples=False,
         flagging_options=None,
         allow_flagging="never"
     )
 
 if __name__ == "__main__":
-    # Informacje o dostępnych urządzeniach
     logger.info("=== Informacje o systemie ===")
     logger.info(f"CUDA dostępne: {torch.cuda.is_available()}")
     logger.info(f"MPS dostępne: {torch.backends.mps.is_available()}")
@@ -261,12 +222,11 @@ if __name__ == "__main__":
     if torch.cuda.is_available():
         logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
     
-    # Uruchomienie interfejsu
     interface = create_interface()
     interface.launch(
-        server_name="127.0.0.1",  # Bezpieczniejsze niż domyślne
+        server_name="0.0.0.0",  # Zmieniono z 127.0.0.1
         server_port=7860,
-        share=False,  # Nie udostępniaj publicznie
-        debug=False,  # Wyłącz w produkcji
+        share=False,
+        debug=False,
         show_error=True
     )