Video işleme süreci güncellendi; artık faster-whisper modeli kullanılıyor ve işlem sırası tek tek gerçekleştiriliyor. Dockerfile'a libsndfile1 bağımlılığı eklendi. Kodda gereksiz kütüphaneler kaldırıldı ve hata yönetimi ile logging iyileştirildi.

Dockerfile

@@ -1,5 +1,5 @@
 FROM python:3.10
-RUN apt-get update && apt-get install -y ffmpeg
+RUN apt-get update && apt-get install -y ffmpeg libsndfile1
 WORKDIR /app
 COPY requirements.txt .
 RUN pip install -r requirements.txt

main-videopluskazanim.py

@@ -35,12 +35,10 @@ from typing import List, Dict, Optional
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
 import torch
 import functools
-import asyncio
-import concurrent.futures
-import threading
+# asyncio, concurrent.futures, threading kaldırıldı - direkt sequential processing
 import kazanim_id_konu_isim_dict_list as kazanimlar
 import logging
-import whisper
+from faster_whisper import WhisperModel
 import tempfile
 import os
 import logging
@@ -123,77 +121,87 @@ def load_pipeline(model_name: str):
         raise HTTPException(status_code=500, detail=f"Model yükleme hatası: {str(e)}")
 
 @functools.lru_cache(maxsize=4)
-def load_whisper_model(model_name: str):
-    """Whisper model yükleme"""
+def load_faster_whisper_model(model_name: str):
+    """faster-whisper model yükleme"""
     try:
-        print(f"Whisper modeli yükleniyor: {model_name}")
-        model = whisper.load_model(model_name)
-        print(f"Whisper modeli başarıyla yüklendi: {model_name}")
+        print(f"faster-whisper modeli yükleniyor: {model_name}")
+        
+        # CPU/GPU device seçimi
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        compute_type = "float16" if device == "cuda" else "int8"
+        
+        print(f"Device: {device}, Compute type: {compute_type}")
+        
+        # faster-whisper modeli yükle
+        model = WhisperModel(model_name, device=device, compute_type=compute_type)
+        print(f"✅ faster-whisper modeli başarıyla yüklendi: {model_name}")
         return model
         
     except Exception as e:
-        print(f"Whisper model yükleme hatası ({model_name}): {e}")
-        raise HTTPException(status_code=500, detail=f"Whisper model yükleme hatası: {str(e)}")
+        print(f"faster-whisper model yükleme hatası ({model_name}): {e}")
+        raise HTTPException(status_code=500, detail=f"faster-whisper model yükleme hatası: {str(e)}")
     
 import time, logging, sys
 logging.basicConfig(stream=sys.stdout,
                     level=logging.INFO,
                     format="%(asctime)s  %(levelname)s  %(message)s")
 
-# Thread pool for parallel processing - HF Space friendly
-# HF Space'lerde çok aggressive olmamak için worker sayısını azalttık
-executor = concurrent.futures.ThreadPoolExecutor(max_workers=4)
+# WORKER YOK - Direkt sequential processing
+# faster-whisper kullanıyoruz artık
 
-# Thread-safe model kullanımı için lock
-whisper_lock = threading.Lock()
-
-async def process_single_video(file: UploadFile, model, language: str) -> VideoResult:
-    """Tek bir video dosyasını işle - THREAD SAFE paralel kullanım için"""
+async def prepare_video_file(file: UploadFile) -> tuple[str, str]:
+    """Video dosyasını geçici dizine kaydet - Validation ile"""
     if not file.filename.lower().endswith(('.mp4', '.wav', '.mp3', '.m4a', '.flac')):
-        return VideoResult(id=file.filename, text="")
+        return file.filename, ""
     
     # Geçici dosya oluştur
-    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
+    original_ext = os.path.splitext(file.filename)[1]
+    with tempfile.NamedTemporaryFile(delete=False, suffix=original_ext) as temp_file:
         content = await file.read()
         temp_file.write(content)
         temp_file_path = temp_file.name
     
-    def transcribe_sync():
-        """Senkron transcription - thread pool'da çalışacak - THREAD SAFE"""
-        try:
-            # 🔒 THREAD SAFETY: Model kullanımını serialize et
-            with whisper_lock:
-                print(f"🔄 {file.filename}: Model kullanımı başlıyor...")
-                result = model.transcribe(
-                    temp_file_path, 
-                    language=language.lower(), 
-                    verbose=False
-                )
-                text = result['text'].strip()
-                
-                # Model çıktısının bir kısmını logla (debug için)
-                preview = text[:150] + "..." if len(text) > 150 else text
-                print(f"📝 {file.filename}: {preview}")
-            
-            return text
-            
-        except Exception as e:
-            print(f"❌ Video işleme hatası ({file.filename}): {e}")
-            return ""
-            
-        finally:
-            # Geçici dosyayı temizle
-            if os.path.exists(temp_file_path):
-                try:
-                    os.unlink(temp_file_path)
-                except:
-                    pass  # HF Space'te silme hatası olabilir
+    # FILE VALIDATION: Dosya boyutu kontrolü
+    file_size = len(content)
+    if file_size < 1000:  # 1KB'den küçükse corrupt
+        print(f"❌ {file.filename}: Dosya çok küçük ({file_size} bytes)")
+        os.unlink(temp_file_path)
+        return file.filename, ""
     
-    # Thread pool'da transcription çalıştır
-    loop = asyncio.get_event_loop()
-    text = await loop.run_in_executor(executor, transcribe_sync)
-    
-    return VideoResult(id=file.filename, text=text)
+    print(f"✅ {file.filename}: Dosya geçerli ({file_size} bytes)")
+    return file.filename, temp_file_path
+
+def process_single_video_sync(file_path: str, filename: str, model, language: str) -> VideoResult:
+    """Tek bir video dosyasını işle - DIREKT SEQUENTIAL (worker yok)"""
+    try:
+        print(f"🔄 {filename}: faster-whisper ile işleniyor...")
+        
+        # faster-whisper ile transcription
+        segments, info = model.transcribe(file_path, language=language.lower())
+        
+        # Segmentleri birleştir
+        text = ""
+        for segment in segments:
+            text += segment.text
+        text = text.strip()
+        
+        # Model çıktısının bir kısmını logla (debug için)
+        preview = text[:150] + "..." if len(text) > 150 else text
+        print(f"📝 {filename}: {preview}")
+        
+        return VideoResult(id=filename, text=text)
+        
+    except Exception as e:
+        print(f"❌ Video işleme hatası ({filename}): {e}")
+        return VideoResult(id=filename, text="")
+        
+    finally:
+        # Geçici dosyayı temizle
+        if os.path.exists(file_path):
+            try:
+                os.unlink(file_path)
+            except:
+                pass
 
 @app.post("/predict", response_model=PredictResponse)   
 async def predict(req: PredictRequest):
@@ -231,57 +239,118 @@ async def predict(req: PredictRequest):
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=f"Hata: {str(e)}")
 
+@app.post("/whisper-single", response_model=WhisperResponse)
+async def transcribe_single_video(file: UploadFile = File(...), 
+                                model_name: str = "small", 
+                                language: str = "Turkish",
+                                ustkurumid: Optional[str] = None,
+                                testid: Optional[str] = None, 
+                                soruno: Optional[str] = None):
+    """TEK VİDEO işleme - Bug'sız tek tek processing"""
+    t0 = time.time()
+    print(f"🎯 TEK VIDEO işleme başlıyor: {file.filename}")
+    print(f"📊 Request info: ustkurumid={ustkurumid}, testid={testid}, soruno={soruno}")
+    
+    try:
+        if not file.filename.lower().endswith(('.mp4', '.wav', '.mp3', '.m4a', '.flac')):
+            raise HTTPException(status_code=400, detail="Desteklenmeyen dosya formatı")
+
+        # faster-whisper Model yükle
+        model = load_faster_whisper_model(model_name)
+        
+        # Dosyayı hazırla
+        print(f"📁 Dosya hazırlanıyor: {file.filename}")
+        file_name, file_path = await prepare_video_file(file)
+        
+        if not file_path:
+            return WhisperResponse(model=model_name, results=[VideoResult(id=file_name, text="")])
+        
+        print(f"🚀 Transcription başlıyor: {file_name}")
+        
+        # faster-whisper ile TEK VİDEO işleme - Bug yok!
+        segments, info = model.transcribe(file_path, language=language.lower())
+        
+        # Segmentleri birleştir
+        text = ""
+        for segment in segments:
+            text += segment.text
+        text = text.strip()
+        
+        # Model çıktısının bir kısmını logla
+        preview = text[:150] + "..." if len(text) > 150 else text
+        print(f"📝 {file_name}: {preview}")
+        
+        # Geçici dosyayı temizle
+        try:
+            os.unlink(file_path)
+        except:
+            pass
+        
+        dt = time.time() - t0
+        print(f"✅ TEK VIDEO tamamlandı | took {dt:.2f}s")
+        
+        return WhisperResponse(model=model_name, results=[VideoResult(id=file_name, text=text)])
+        
+    except Exception as e:
+        print(f"❌ Tek video hatası: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Tek video hatası: {str(e)}")
+
 @app.post("/whisper", response_model=WhisperResponse)   
 async def transcribe_videos(files: List[UploadFile] = File(...), 
                           model_name: str = "small", 
-                          language: str = "Turkish"):
-    """Video dosyalarını metne çevir - PARALEL İŞLEME"""
+                          language: str = "Turkish",
+                          ustkurumid: Optional[str] = None,
+                          testid: Optional[str] = None, 
+                          soruno: Optional[str] = None):
+    """Video dosyalarını metne çevir - TEK TEK İŞLEME (Bug'sız)"""
     t0 = time.time()
-    print(f"🚀 new whisper request /model = {model_name} / n = {len(files)} - PARALEL İŞLEME BAŞLIYOR")
+    print(f"🎯 TEK TEK whisper request /model = {model_name} / n = {len(files)} - SEQUENTIAL İŞLEME")
+    print(f"📊 Batch Request info: ustkurumid={ustkurumid}, testid={testid}, soruno={soruno}")
     
     try:
         if not files:
             raise HTTPException(status_code=400, detail="Video dosyaları boş olamaz")
 
-        # Whisper modelini yükle
-        model = load_whisper_model(model_name)
+        # faster-whisper modelini yükle
+        model = load_faster_whisper_model(model_name)
         
-        # HF SPACE İÇİN CHUNK'LI PARALEL İŞLEME
-        chunk_size = 16  # HF Space için güvenli chunk boyutu
+        # 🎯 TEK TEK SEQUENTIAL İŞLEME - Bug'sız!
         final_results = []
         
-        print(f"📡 {len(files)} dosya {chunk_size}'lı chunk'larda paralel işlenecek...")
+        print(f"📝 {len(files)} dosya tek tek sırayla işlenecek (bug'sız)...")
         
-        # Dosyaları chunk'lara böl ve her chunk'ı paralel işle
-        for i in range(0, len(files), chunk_size):
-            chunk = files[i:i + chunk_size]
-            print(f"🔄 Chunk {i//chunk_size + 1}: {len(chunk)} dosya işleniyor...")
+        # Her dosyayı sırasıyla tek tek işle
+        for i, file in enumerate(files):
+            print(f"🔄 Video {i+1}/{len(files)}: {file.filename} işleniyor...")
             
-            # Bu chunk'ı paralel işle
-            tasks = [process_single_video(file, model, language) for file in chunk]
-            chunk_results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            # Exception'ları handle et + SUCCESS/ERROR COUNT
-            success_count = 0
-            error_count = 0
-            for j, result in enumerate(chunk_results):
-                if isinstance(result, Exception):
-                    print(f"❌ Dosya {chunk[j].filename} işlenirken hata: {result}")
-                    final_results.append(VideoResult(id=chunk[j].filename, text=""))
-                    error_count += 1
+            try:
+                # Dosyayı hazırla
+                file_name, file_path = await prepare_video_file(file)
+                
+                if not file_path:
+                    final_results.append(VideoResult(id=file_name, text=""))
+                    continue
+                
+                # TEK TEK işleme - DIREKT SEQUENTIAL
+                result = process_single_video_sync(file_path, file_name, model, language)
+                final_results.append(result)
+                
+                # Başarı durumunu logla
+                if result.text.strip():
+                    print(f"✅ {file.filename}: Başarılı!")
                 else:
-                    final_results.append(result)
-                    # Başarılı sayısı = boş olmayan text'ler
-                    if result.text.strip():
-                        success_count += 1
-                    else:
-                        error_count += 1
-            
-            print(f"✅ Chunk {i//chunk_size + 1} tamamlandı! ✅{success_count} ❌{error_count}")
+                    print(f"❌ {file.filename}: Boş sonuç!")
+                    
+            except Exception as e:
+                print(f"❌ {file.filename}: İşleme hatası: {e}")
+                final_results.append(VideoResult(id=file.filename, text=""))
             
-            # Memory'yi rahatlatmak için küçük bir bekleme (HF Space için)
-            if i + chunk_size < len(files):
-                await asyncio.sleep(0.1)
+            # Her dosya arasında kısa bekleme (stability için)
+            if i < len(files) - 1:
+                import asyncio
+                await asyncio.sleep(0.5)
         
         dt = time.time() - t0
         
@@ -290,9 +359,9 @@ async def transcribe_videos(files: List[UploadFile] = File(...),
         total_failed = len(final_results) - total_success
         success_rate = (total_success / len(final_results) * 100) if final_results else 0
         
-        print(f"✅ Whisper PARALEL done | took {dt:.2f}s")
-        print(f"🎯 SONUÇ: {len(final_results)} video | ✅{total_success} başarılı | ❌{total_failed} hatalı | 📊{success_rate:.1f}% başarı oranı")
-        print(f"⚡ Hız: {len(final_results)/dt:.1f} video/saniye (chunk_size={chunk_size})")
+        print(f"✅ Whisper SEQUENTIAL done | took {dt:.2f}s")
+        print(f"🎯 TEK TEK SONUÇ: {len(final_results)} video | ✅{total_success} başarılı | ❌{total_failed} hatalı | 📊{success_rate:.1f}% başarı oranı")
+        print(f"⚡ SEQUENTIAL HIZI: {len(final_results)/dt:.1f} video/saniye | Bug'sız stabil!")
         
         return WhisperResponse(model=model_name, results=final_results)
         
@@ -318,14 +387,15 @@ def health_check():
             device_info = f"GPU: {gpu_name}"
 
         bert_models = load_pipeline.cache_info().currsize if hasattr(load_pipeline, 'cache_info') else 0
-        whisper_models = load_whisper_model.cache_info().currsize if hasattr(load_whisper_model, 'cache_info') else 0
+        whisper_models = load_faster_whisper_model.cache_info().currsize if hasattr(load_faster_whisper_model, 'cache_info') else 0
         
         return {
             "status": "healthy", 
             "device": device_info,
             "bert_models_loaded": bert_models,
             "whisper_models_loaded": whisper_models,
-            "endpoints": ["/predict", "/whisper", "/health"]
+            "endpoints": ["/predict", "/whisper", "/whisper-single", "/health"],
+            "processing_mode": "SEQUENTIAL - Tek tek bug'sız işleme"
         }
     except Exception as e:
         return {"status": "error", "message": f"Sağlık kontrolü hatası: {str(e)}"}

requirements.txt

@@ -8,6 +8,6 @@ uvicorn
 python-multipart
 requests
 pandas
-openai-whisper==20250625
+faster-whisper
 typing-extensions
 ffmpeg-python