Update denoiser.py

denoiser.py

@@ -1,33 +1,136 @@
+"""
+Department 1 — Denoiser
+Primary  : Cleanvoice API — handles ALL audio enhancement:
+           noise removal, studio sound, fillers, stutters,
+           breaths, mouth sounds, long silences
+Fallback : Returns preprocessed 16kHz mono WAV if API fails
+
+FIXES APPLIED:
+- Removed dead _remove_fillers / _remove_stutters stubs
+- Added logging for better observability
+- FFmpeg errors are now logged (not silently ignored)
+- Temp file cleanup to prevent disk leaks
+- Expanded filler word list for clean_transcript_fillers()
+"""
+
 import os
+import re
+import logging
 import requests
 import subprocess
-import re
+
+logger = logging.getLogger(__name__)
+
+# ══════════════════════════════════════════════════════════════════
+# FILLER WORDS — English + common Indic spoken fillers
+# Used only for transcript text cleanup (not audio)
+# ══════════════════════════════════════════════════════════════════
+FILLER_PATTERN = re.compile(
+    r'\b(um+|uh+|hmm+|hm+|mhm|ah|oh|basically|literally|'
+    r'actually|honestly|like|you\s+know|i\s+mean|'
+    r'ante|ane|matlab|yaani|artha|mane)\b',
+    flags=re.IGNORECASE
+)
+
 
 class Denoiser:
     def __init__(self):
-        self.api_key = os.environ.get("CLEANVOICE_API_KEY","")
+        self.api_key = os.environ.get("CLEANVOICE_API_KEY", "")
+        if self.api_key:
+            logger.info("[Denoiser] ✅ Cleanvoice API key found")
+        else:
+            logger.warning("[Denoiser] ⚠️ No CLEANVOICE_API_KEY — will use preprocessed WAV as fallback")
 
-    def process(self, audio_path, out_dir, **kwargs):
-        # Pre-convert to WAV to ensure the API never fails on AAC/Opus
+    # ══════════════════════════════════════════════════════════════
+    # PUBLIC — MAIN PROCESS
+    # ══════════════════════════════════════════════════════════════
+    def process(self, audio_path: str, out_dir: str, **kwargs) -> dict:
+        """
+        Step 1: Convert audio to 16kHz mono WAV (required by Cleanvoice)
+        Step 2: Send to Cleanvoice API — it handles ALL enhancement
+        Step 3: Download cleaned audio and return path
+        Fallback: Return preprocessed WAV if API fails
+        """
         standard_wav = os.path.join(out_dir, "internal_process.wav")
-        subprocess.run(["ffmpeg", "-y", "-i", audio_path, "-ar", "16000", "-ac", "1", standard_wav], capture_output=True)
 
+        # Convert to 16kHz mono WAV before sending to API
+        convert_ok = self._ffmpeg_convert(audio_path, standard_wav)
+        if not convert_ok:
+            logger.error("[Denoiser] FFmpeg conversion failed — using original file")
+            standard_wav = audio_path
+
+        # Send to Cleanvoice API
         try:
+            if not self.api_key:
+                raise ValueError("No CLEANVOICE_API_KEY set in environment")
+
             from cleanvoice import Cleanvoice
             cv = Cleanvoice({'api_key': self.api_key})
-            result = cv.process(standard_wav, remove_noise=True, studio_sound=True, **kwargs)
-            
-            audio_data = requests.get(result.audio.url).content
+
+            logger.info("[Denoiser] Sending audio to Cleanvoice API...")
+            result = cv.process(
+                standard_wav,
+                remove_noise=True,
+                studio_sound=True,
+                **kwargs  # fillers, stutters, long_silences, breaths, mouth_sounds
+            )
+
+            # Download cleaned audio from Cleanvoice result URL
+            audio_data = requests.get(result.audio.url, timeout=60).content
             clean_wav = os.path.join(out_dir, "clean_internal.wav")
             with open(clean_wav, "wb") as f:
                 f.write(audio_data)
+
+            logger.info("[Denoiser] ✅ Cleanvoice enhancement complete")
             return {'audio_path': clean_wav}
-        except Exception:
+
+        except Exception as e:
+            logger.warning(f"[Denoiser] Cleanvoice failed: {e} — using preprocessed WAV")
             return {'audio_path': standard_wav}
 
-    def clean_transcript_fillers(self, text):
-        fillers = r'\b(um|uh|hmm|basically|like|ante|ane|matlab)\b'
-        return re.sub(fillers, '', text, flags=re.IGNORECASE).strip()
+    # ══════════════════════════════════════════════════════════════
+    # PUBLIC — TRANSCRIPT FILLER CLEANER
+    # Cleans filler words from transcript text only (not audio)
+    # Audio-level cleaning is done by Cleanvoice API
+    # ══════════════════════════════════════════════════════════════
+    def clean_transcript_fillers(self, text: str) -> str:
+        """Remove filler words from transcript text and fix extra spaces."""
+        cleaned = FILLER_PATTERN.sub('', text)
+        cleaned = re.sub(r'\s{2,}', ' ', cleaned).strip()
+        return cleaned
+
+    # ══════════════════════════════════════════════════════════════
+    # PRIVATE — FFmpeg Conversion
+    # ══════════════════════════════════════════════════════════════
+    def _ffmpeg_convert(self, input_path: str, output_path: str) -> bool:
+        """Convert any audio format to 16kHz mono PCM WAV. Returns True on success."""
+        try:
+            result = subprocess.run(
+                ["ffmpeg", "-y", "-i", input_path,
+                 "-ar", "16000", "-ac", "1", "-acodec", "pcm_s16le",
+                 output_path],
+                capture_output=True
+            )
+            if result.returncode == 0 and os.path.exists(output_path):
+                return True
+            logger.warning(f"[Denoiser] FFmpeg error: {result.stderr.decode()[:200]}")
+            return False
+        except Exception as e:
+            logger.error(f"[Denoiser] FFmpeg exception: {e}")
+            return False
 
-    def _remove_fillers(self, a, s, seg): return a, 0
-    def _remove_stutters(self, a, s, seg): return a, 0
+    # ══════════════════════════════════════════════════════════════
+    # PUBLIC — Temp File Cleanup (call after pipeline is done)
+    # ══════════════════════════════════════════════════════════════
+    def cleanup_temp_files(self, out_dir: str):
+        """Delete intermediate WAV files to prevent disk leaks."""
+        temp_files = [
+            os.path.join(out_dir, "internal_process.wav"),
+        ]
+        for f in temp_files:
+            if os.path.exists(f):
+                try:
+                    os.remove(f)
+                    logger.info(f"[Denoiser] Cleaned up: {f}")
+                except Exception as e:
+                    logger.warning(f"[Denoiser] Could not delete {f}: {e}")