Update denoiser.py

denoiser.py

@@ -1,66 +1,65 @@
 """
-Denoiser — Cleanvoice API
-BUGS FIXED:
-  1. cv.process() needs PUBLIC URL not local path
-     → Upload to Cloudinary first, get URL, send to Cleanvoice
-  2. Wrong parameter names (fillers=, stutters=)
-     → Correct config dict: {'fillers':True,'stutters':True,...}
-  3. Wrong SDK call syntax
-     → cv.process(url, config_dict) not cv.process(path, **kwargs)
-  4. Silent error swallowing (except Exception: pass)
-     → Now logs all errors so you can see what's failing
-  5. No stats returned
-     → Now returns stats dict with noise_method etc.
+Denoiser — Cleanvoice API (direct file upload, NO Cloudinary needed)
+
+How it works:
+  1. Convert input audio to 16kHz mono WAV (ffmpeg)
+  2. Upload WAV file directly to Cleanvoice API as multipart/form-data
+  3. Poll Cleanvoice until job is done
+  4. Download and return the cleaned audio
+  5. Return stats dict
+
+No Cloudinary, no public URL needed.
+Only requires: CLEANVOICE_API_KEY in HF Space secrets.
+
+Cleanvoice REST API:
+  POST https://api.cleanvoice.ai/v2/edits  → submit job
+  GET  https://api.cleanvoice.ai/v2/edits/{id} → poll status
 """
 
 import os
 import re
 import time
 import logging
-import requests
 import subprocess
-import cloudinary
-import cloudinary.uploader
+import requests
 
 logger = logging.getLogger(__name__)
 
-# Cloudinary config — set in HF Space secrets
-cloudinary.config(
-    cloud_name = os.environ.get("CLOUD_NAME"),
-    api_key    = os.environ.get("API_KEY"),
-    api_secret = os.environ.get("API_SECRET"),
-)
-
 CLEANVOICE_API_KEY = os.environ.get(
     "CLEANVOICE_API_KEY",
     "cvk_Xnmz7ZPXMRg.CcE3YGry3IzkCBWQKGvomBfd9hmC9L-aAvSj-2iNfyw"
 )
 
-# Filler words for transcript cleaning
+CLEANVOICE_BASE   = "https://api.cleanvoice.ai/v2"
+POLL_INTERVAL_SEC = 5      # seconds between status checks
+POLL_TIMEOUT_SEC  = 600    # 10 minutes max wait
+
+# Filler words removed from transcript text (text-side cleanup)
 FILLER_PATTERN = r'\b(um|uh|hmm|basically|like|ante|ane|matlab|yani|acha|right|okay)\b'
 
 
 class Denoiser:
     def __init__(self):
-        print("[Denoiser] ✅ Cleanvoice API denoiser ready")
-
+        if CLEANVOICE_API_KEY:
+            print("[Denoiser] ✅ Cleanvoice API key found — ready (no Cloudinary needed)")
+        else:
+            print("[Denoiser] ⚠️  No CLEANVOICE_API_KEY — denoising will be skipped")
+
+    # ══════════════════════════════════════════════════════════════════
+    # PUBLIC
+    # ══════════════════════════════════════════════════════════════════
     def process(self, audio_path: str, out_dir: str,
                 remove_fillers: bool = True,
                 remove_stutters: bool = True,
                 remove_silences: bool = True,
                 **kwargs) -> dict:
         """
-        Process audio using Cleanvoice API.
-        Steps:
-          1. Convert to WAV (16kHz mono)
-          2. Upload to Cloudinary → get public URL
-          3. Send URL to Cleanvoice API
-          4. Download cleaned audio
-          5. Return {'audio_path': ..., 'stats': {...}}
+        Process audio using Cleanvoice API (direct file upload).
+        Returns {'audio_path': str, 'stats': dict}
         """
-        stats = {"noise_method": "Cleanvoice API"}
+        stats = {"noise_method": "Cleanvoice API (direct upload)"}
 
-        # ── Step 1: Convert to standard WAV ──────────────────────────
+        # ── Step 1: Convert to 16kHz mono WAV ────────────────────────
         standard_wav = os.path.join(out_dir, "input_converted.wav")
         result = subprocess.run([
             "ffmpeg", "-y", "-i", audio_path,
@@ -72,80 +71,174 @@ class Denoiser:
             logger.error(f"[Denoiser] FFmpeg conversion failed: {result.stderr.decode()}")
             return {"audio_path": audio_path, "stats": stats}
 
-        # ── Step 2: Upload to Cloudinary → get public URL ─────────────
-        public_url = None
+        print(f"[Denoiser] ✅ Converted to 16kHz mono WAV")
+
+        # ── Step 2: Check API key ─────────────────────────────────────
+        if not CLEANVOICE_API_KEY:
+            logger.warning("[Denoiser] No API key — skipping Cleanvoice, returning converted WAV")
+            stats["noise_method"] = "Skipped (no API key)"
+            return {"audio_path": standard_wav, "stats": stats}
+
+        # ── Step 3: Submit job via direct file upload ─────────────────
         try:
-            print("[Denoiser] Uploading to Cloudinary for public URL...")
-            upload_result = cloudinary.uploader.upload(
+            job_id = self._submit_job(
                 standard_wav,
-                resource_type = "video",
-                folder        = "clearwave_input",
+                remove_fillers=remove_fillers,
+                remove_stutters=remove_stutters,
+                remove_silences=remove_silences,
             )
-            public_url = upload_result["secure_url"]
-            print(f"[Denoiser] ✅ Uploaded: {public_url}")
+            print(f"[Denoiser] ✅ Cleanvoice job submitted: {job_id}")
         except Exception as e:
-            logger.error(f"[Denoiser] Cloudinary upload failed: {e}")
-            logger.warning("[Denoiser] Cannot call Cleanvoice without public URL — returning original")
+            logger.error(f"[Denoiser] Job submission failed: {e}", exc_info=True)
+            stats["noise_method"] = f"Cleanvoice submit failed: {str(e)[:120]}"
             return {"audio_path": standard_wav, "stats": stats}
 
-        # ── Step 3: Call Cleanvoice API with correct config ───────────
+        # ── Step 4: Poll until done ───────────────────────────────────
+        try:
+            download_url = self._poll_job(job_id)
+            print(f"[Denoiser] ✅ Cleanvoice done: {download_url}")
+        except Exception as e:
+            logger.error(f"[Denoiser] Polling failed: {e}", exc_info=True)
+            stats["noise_method"] = f"Cleanvoice poll failed: {str(e)[:120]}"
+            return {"audio_path": standard_wav, "stats": stats}
+
+        # ── Step 5: Download cleaned audio ────────────────────────────
         try:
-            from cleanvoice import Cleanvoice
-
-            cv = Cleanvoice({"api_key": CLEANVOICE_API_KEY})
-
-            # FIX: Correct config dict format from Cleanvoice docs
-            config = {
-                "remove_noise":  True,
-                "normalize":     True,
-                "studio_sound":  "nightly",   # best quality
-            }
-            if remove_fillers:
-                config["fillers"]     = True
-                config["hesitations"] = True
-            if remove_stutters:
-                config["stutters"] = True
-            if remove_silences:
-                config["long_silences"] = True
-
-            print(f"[Denoiser] Calling Cleanvoice with config: {config}")
-
-            # FIX: cv.process(PUBLIC_URL, config_dict)
-            cv_result = cv.process(public_url, config)
-
-            # Download cleaned audio
-            cleaned_url = cv_result.audio.url
-            print(f"[Denoiser] ✅ Cleanvoice done: {cleaned_url}")
-
-            audio_data = requests.get(cleaned_url, timeout=120).content
             clean_wav  = os.path.join(out_dir, "cleanvoice_output.wav")
+            audio_data = requests.get(download_url, timeout=120).content
             with open(clean_wav, "wb") as f:
                 f.write(audio_data)
-
-            stats.update({
-                "noise_method":     "Cleanvoice API ✅",
-                "fillers_removed":  "yes" if remove_fillers  else "no",
-                "stutters_removed": "yes" if remove_stutters else "no",
-                "silences_removed": "yes" if remove_silences else "no",
-            })
-            print("[Denoiser] ✅ Cleanvoice processing complete")
-            return {"audio_path": clean_wav, "stats": stats}
-
+            print(f"[Denoiser] ✅ Cleaned audio saved")
         except Exception as e:
-            # FIX: Log the actual error instead of silently ignoring it
-            logger.error(f"[Denoiser] Cleanvoice API failed: {e}", exc_info=True)
-            print(f"[Denoiser] ⚠️ Cleanvoice failed ({e}) — returning converted WAV")
-            stats["noise_method"] = f"Cleanvoice failed: {str(e)[:100]}"
+            logger.error(f"[Denoiser] Download failed: {e}", exc_info=True)
+            stats["noise_method"] = f"Cleanvoice download failed: {str(e)[:120]}"
             return {"audio_path": standard_wav, "stats": stats}
 
+        stats.update({
+            "noise_method":     "Cleanvoice API ✅",
+            "fillers_removed":  "yes" if remove_fillers  else "no",
+            "stutters_removed": "yes" if remove_stutters else "no",
+            "silences_removed": "yes" if remove_silences else "no",
+        })
+        return {"audio_path": clean_wav, "stats": stats}
+
+    # ══════════════════════════════════════════════════════════════════
+    # SUBMIT JOB — direct multipart file upload (no public URL needed)
+    # ══════════════════════════════════════════════════════════════════
+    def _submit_job(self, wav_path: str,
+                    remove_fillers=True,
+                    remove_stutters=True,
+                    remove_silences=True) -> str:
+        """
+        POST /v2/edits with multipart file upload.
+        Returns job_id string.
+        """
+        headers = {"x-api-key": CLEANVOICE_API_KEY}
+
+        # Build config payload as form fields
+        config = {"export_format": "wav"}
+        if remove_fillers:
+            config["filler_words"]  = "true"
+            config["hesitations"]   = "true"
+        if remove_stutters:
+            config["stutters"]      = "true"
+        if remove_silences:
+            config["long_silences"] = "true"
+
+        print(f"[Denoiser] Submitting to Cleanvoice: {config}")
+
+        with open(wav_path, "rb") as f:
+            resp = requests.post(
+                f"{CLEANVOICE_BASE}/edits",
+                headers=headers,
+                files={"audio": (os.path.basename(wav_path), f, "audio/wav")},
+                data=config,
+                timeout=120,
+            )
+
+        if resp.status_code not in (200, 201, 202):
+            raise RuntimeError(
+                f"Cleanvoice submit HTTP {resp.status_code}: {resp.text[:300]}"
+            )
+
+        data = resp.json()
+
+        # Cleanvoice returns { "id": "..." } or { "data": { "id": "..." } }
+        job_id = (
+            data.get("id")
+            or data.get("edit_id")
+            or (data.get("data") or {}).get("id")
+        )
+        if not job_id:
+            raise RuntimeError(f"No job ID in Cleanvoice response: {data}")
+
+        return str(job_id)
+
+    # ══════════════════════════════════════════════════════════════════
+    # POLL JOB
+    # ══════════════════════════════════════════════════════════════════
+    def _poll_job(self, job_id: str) -> str:
+        """
+        GET /v2/edits/{job_id} until status == done.
+        Returns download URL of cleaned audio.
+        """
+        headers  = {"x-api-key": CLEANVOICE_API_KEY}
+        url      = f"{CLEANVOICE_BASE}/edits/{job_id}"
+        deadline = time.time() + POLL_TIMEOUT_SEC
+        attempt  = 0
+
+        while time.time() < deadline:
+            attempt += 1
+            resp = requests.get(url, headers=headers, timeout=30)
+
+            if resp.status_code != 200:
+                raise RuntimeError(
+                    f"Cleanvoice poll HTTP {resp.status_code}: {resp.text[:200]}"
+                )
+
+            data  = resp.json()
+            inner = data.get("data", data)   # unwrap nested if present
+            status = (inner.get("status") or "").lower()
+
+            print(f"[Denoiser] Poll #{attempt} — status: {status}")
+
+            if status in ("done", "finished", "completed", "success"):
+                # Try all common keys for the output URL
+                download_url = (
+                    inner.get("output_url")
+                    or inner.get("download_url")
+                    or inner.get("audio_url")
+                    or inner.get("url")
+                    or (inner.get("output") or {}).get("url")
+                    or (inner.get("result")  or {}).get("url")
+                )
+                if not download_url:
+                    raise RuntimeError(
+                        f"Cleanvoice job done but no download URL in response: {inner}"
+                    )
+                return download_url
+
+            elif status in ("error", "failed", "failure"):
+                msg = inner.get("error") or inner.get("message") or str(inner)
+                raise RuntimeError(f"Cleanvoice job failed: {msg}")
+
+            # Still processing — wait and retry
+            time.sleep(POLL_INTERVAL_SEC)
+
+        raise TimeoutError(
+            f"Cleanvoice job {job_id} did not finish within {POLL_TIMEOUT_SEC}s"
+        )
+
+    # ══════════════════════════════════════════════════════════════════
+    # TEXT-SIDE FILLER CLEANUP
+    # ══════════════════════════════════════════════════════════════════
     def clean_transcript_fillers(self, text: str) -> str:
         """Remove filler words from transcript text."""
         cleaned = re.sub(FILLER_PATTERN, '', text, flags=re.IGNORECASE)
-        # Clean up extra spaces
         cleaned = re.sub(r'\s+', ' ', cleaned).strip()
         return cleaned
 
-    # Kept for compatibility — not used with Cleanvoice API
+    # Kept for compatibility
     def _remove_fillers(self, a, s, seg):
         return a, 0