Upload 4 files

__init__.py

@@ -0,0 +1,6 @@
+# services/__init__.py
+from .denoiser import Denoiser
+from .transcriber import Transcriber
+from .translator import Translator
+
+__all__ = ["Denoiser", "Transcriber", "Translator"]

denoiser.py

@@ -0,0 +1,159 @@
+"""
+Department 1 — Denoiser
+Uses DeepFilterNet3 for professional noise removal.
+Processing order:
+  convert format → read → stereo→mono → resample →
+  gentle pre-boost (max 3×) → AI denoise → EBU R128 normalize → save
+"""
+
+import os
+import time
+import subprocess
+import tempfile
+import numpy as np
+import soundfile as sf
+import logging
+
+logger = logging.getLogger(__name__)
+
+TARGET_SR     = 48_000   # DeepFilterNet3 native sample rate
+TARGET_LOUDNESS = -23.0  # EBU R128 target LUFS
+PRE_BOOST_MAX = 3.0      # max linear gain before denoise
+
+
+class Denoiser:
+    def __init__(self):
+        print("[Denoiser] Initialising DeepFilterNet3…")
+        try:
+            from df.enhance import enhance, init_df, load_audio, save_audio
+            self._enhance   = enhance
+            self._init_df   = init_df
+            self._load_audio = load_audio
+            self._save_audio = save_audio
+
+            # Load model once
+            self.model, self.df_state, _ = init_df()
+            print("[Denoiser] ✅ DeepFilterNet3 loaded")
+        except Exception as e:
+            logger.warning(f"[Denoiser] DeepFilterNet3 not available: {e}")
+            self.model = None
+
+    # ── Public ──────────────────────────────────────────────────────
+    def process(self, audio_path: str, out_dir: str) -> str:
+        """
+        Full pipeline: convert → load → mono → resample →
+        pre-boost → denoise → normalise → save.
+        Returns path to denoised WAV.
+        """
+        t0 = time.time()
+
+        # Step 1: Convert any format → WAV via ffmpeg
+        wav_path = os.path.join(out_dir, "input.wav")
+        self._convert_to_wav(audio_path, wav_path)
+
+        # Step 2: Read audio
+        audio, sr = sf.read(wav_path, always_2d=True)   # shape (samples, channels)
+
+        # Step 3: Stereo → mono
+        if audio.ndim > 1 and audio.shape[1] > 1:
+            audio = audio.mean(axis=1)
+        else:
+            audio = audio.squeeze()
+
+        # Step 4: Resample to 48 kHz
+        if sr != TARGET_SR:
+            audio = self._resample(audio, sr, TARGET_SR)
+            sr = TARGET_SR
+
+        # Step 5: Gentle pre-boost (max 3×)
+        peak = np.abs(audio).max()
+        if peak > 0 and peak < 1.0:
+            boost = min(PRE_BOOST_MAX, 1.0 / peak)
+            audio = audio * boost
+
+        # Clip to [-1, 1] after boost
+        audio = np.clip(audio, -1.0, 1.0).astype(np.float32)
+
+        # Step 6: AI Denoise
+        if self.model is not None:
+            try:
+                # DeepFilterNet3 expects (1, samples) tensor
+                import torch
+                tensor = torch.from_numpy(audio).unsqueeze(0)
+                enhanced = self._enhance(self.model, self.df_state, tensor)
+                audio = enhanced.squeeze(0).numpy()
+            except Exception as e:
+                logger.warning(f"[Denoiser] DeepFilterNet3 enhance failed, using raw: {e}")
+
+        # Step 7: EBU R128 loudness normalisation
+        audio = self._normalise_loudness(audio, sr)
+
+        # Step 8: Save
+        out_path = os.path.join(out_dir, "denoised.wav")
+        sf.write(out_path, audio, sr, subtype="PCM_16")
+
+        logger.info(f"[Denoiser] Done in {time.time()-t0:.2f}s → {out_path}")
+        return out_path
+
+    # ── Private helpers ──────────────────────────────────────────────
+    def _convert_to_wav(self, src: str, dst: str):
+        """Convert any audio format to 16-bit PCM WAV using ffmpeg."""
+        cmd = [
+            "ffmpeg", "-y", "-i", src,
+            "-acodec", "pcm_s16le",
+            "-ar", str(TARGET_SR),
+            "-ac", "1",
+            dst
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            # ffmpeg failed — try soundfile direct read as fallback
+            logger.warning(f"[Denoiser] ffmpeg conversion failed, trying soundfile direct read")
+            try:
+                data, sr_in = sf.read(src, always_2d=True)
+                sf.write(dst, data, sr_in, subtype="PCM_16")
+            except Exception as e2:
+                raise RuntimeError(
+                    f"Could not read audio file '{os.path.basename(src)}'. "
+                    f"ffmpeg error: {result.stderr[:200]}"
+                ) from e2
+
+    def _resample(self, audio: np.ndarray, src_sr: int, tgt_sr: int) -> np.ndarray:
+        try:
+            import resampy
+            return resampy.resample(audio, src_sr, tgt_sr)
+        except ImportError:
+            pass
+        try:
+            import librosa
+            return librosa.resample(audio, orig_sr=src_sr, target_sr=tgt_sr)
+        except ImportError:
+            pass
+        # Simple linear interpolation fallback
+        ratio     = tgt_sr / src_sr
+        n_samples = int(len(audio) * ratio)
+        indices   = np.linspace(0, len(audio) - 1, n_samples)
+        return np.interp(indices, np.arange(len(audio)), audio).astype(np.float32)
+
+    def _normalise_loudness(self, audio: np.ndarray, sr: int) -> np.ndarray:
+        """
+        EBU R128 normalisation.
+        Targets TARGET_LOUDNESS LUFS; falls back to RMS normalisation if
+        pyloudnorm is unavailable.
+        """
+        try:
+            import pyloudnorm as pyln
+            meter    = pyln.Meter(sr)
+            loudness = meter.integrated_loudness(audio)
+            if np.isfinite(loudness) and loudness < 0:
+                audio = pyln.normalize.loudness(audio, loudness, TARGET_LOUDNESS)
+            return np.clip(audio, -1.0, 1.0).astype(np.float32)
+        except Exception:
+            pass
+
+        # RMS fallback
+        rms = np.sqrt(np.mean(audio ** 2))
+        if rms > 1e-9:
+            target_rms = 10 ** (TARGET_LOUDNESS / 20.0)
+            audio = audio * (target_rms / rms)
+        return np.clip(audio, -1.0, 1.0).astype(np.float32)

transcriber.py

@@ -0,0 +1,135 @@
+"""
+Department 2 — Transcriber
+Primary  : Groq API (Whisper large-v3 on H100) — free tier 14 400 s/day
+Fallback : faster-whisper (local, small model) if Groq fails or limit reached
+"""
+
+import os
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Whisper language codes that map to our short codes
+LANG_TO_WHISPER = {
+    "auto": None,
+    "en":   "en",
+    "te":   "te",
+    "hi":   "hi",
+    "ta":   "ta",
+    "kn":   "kn",
+}
+
+
+class Transcriber:
+    def __init__(self):
+        self.groq_key     = os.environ.get("GROQ_API_KEY", "")
+        self._groq_client = None
+        self._local_model = None
+
+        if self.groq_key:
+            print("[Transcriber] Groq API key found — primary = Groq Whisper large-v3")
+            self._init_groq()
+        else:
+            print("[Transcriber] ⚠️  No GROQ_API_KEY — falling back to local Whisper small")
+            self._init_local()
+
+    # ── Public ──────────────────────────────────────────────────────
+    def transcribe(self, audio_path: str, language: str = "auto"):
+        """
+        Returns (transcript_text, detected_language_code, method_label)
+        """
+        lang_hint = LANG_TO_WHISPER.get(language, None)
+
+        if self._groq_client is not None:
+            try:
+                return self._transcribe_groq(audio_path, lang_hint)
+            except Exception as e:
+                logger.warning(f"[Transcriber] Groq failed ({e}), falling back to local…")
+                if self._local_model is None:
+                    self._init_local()
+
+        return self._transcribe_local(audio_path, lang_hint)
+
+    # ── Groq ─────────────────────────────────────────────────────────
+    def _init_groq(self):
+        try:
+            from groq import Groq
+            self._groq_client = Groq(api_key=self.groq_key)
+            print("[Transcriber] ✅ Groq client initialised")
+        except Exception as e:
+            logger.warning(f"[Transcriber] Groq init failed: {e}")
+            self._groq_client = None
+            self._init_local()
+
+    def _transcribe_groq(self, audio_path: str, language=None):
+        t0 = time.time()
+        with open(audio_path, "rb") as f:
+            kwargs = dict(
+                file=f,
+                model="whisper-large-v3",
+                response_format="verbose_json",
+                temperature=0.0,
+            )
+            if language:
+                kwargs["language"] = language
+
+            resp = self._groq_client.audio.transcriptions.create(**kwargs)
+
+        transcript    = resp.text.strip()
+        detected_lang = getattr(resp, "language", language or "en") or "en"
+        # Groq returns full names like "english" — normalise
+        detected_lang = self._normalise_lang(detected_lang)
+
+        logger.info(f"[Transcriber] Groq done in {time.time()-t0:.2f}s, lang={detected_lang}")
+        return transcript, detected_lang, "Groq Whisper large-v3"
+
+    # ── Local Whisper ────────────────────────────────────────────────
+    def _init_local(self):
+        try:
+            from faster_whisper import WhisperModel
+            print("[Transcriber] Loading faster-whisper small (CPU)…")
+            self._local_model = WhisperModel(
+                "small",
+                device="cpu",
+                compute_type="int8",
+            )
+            print("[Transcriber] ✅ faster-whisper small ready")
+        except Exception as e:
+            logger.error(f"[Transcriber] Local Whisper init failed: {e}")
+            self._local_model = None
+
+    def _transcribe_local(self, audio_path: str, language=None):
+        t0 = time.time()
+        if self._local_model is None:
+            raise RuntimeError("No transcription engine available.")
+
+        segments, info = self._local_model.transcribe(
+            audio_path,
+            language=language,
+            beam_size=5,
+            vad_filter=True,
+        )
+        transcript    = " ".join(seg.text.strip() for seg in segments).strip()
+        detected_lang = info.language or language or "en"
+
+        logger.info(f"[Transcriber] Local done in {time.time()-t0:.2f}s, lang={detected_lang}")
+        return transcript, detected_lang, "local Whisper small (fallback)"
+
+    # ── Helpers ──────────────────────────────────────────────────────
+    @staticmethod
+    def _normalise_lang(raw: str) -> str:
+        """Convert Groq full language names to 2-letter codes."""
+        mapping = {
+            "english":  "en",
+            "telugu":   "te",
+            "hindi":    "hi",
+            "tamil":    "ta",
+            "kannada":  "kn",
+            "spanish":  "es",
+            "french":   "fr",
+            "german":   "de",
+            "japanese": "ja",
+            "chinese":  "zh",
+        }
+        return mapping.get(raw.lower(), raw[:2].lower() if len(raw) >= 2 else raw)

translator.py

@@ -0,0 +1,151 @@
+"""
+Department 3 - Translator
+Primary  : NLLB-200-distilled-600M (Meta, offline on ZeroGPU)
+Fallback : deep-translator (Google Translate) if NLLB fails
+"""
+
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Map simple 2-letter UI codes to NLLB-200 language codes
+NLLB_CODES = {
+    "en": "eng_Latn",
+    "te": "tel_Telu",
+    "hi": "hin_Deva",
+    "ta": "tam_Taml",
+    "kn": "kan_Knda",
+    "es": "spa_Latn",
+    "fr": "fra_Latn",
+    "de": "deu_Latn",
+    "ja": "jpn_Jpan",
+    "zh": "zho_Hans",
+    "ar": "arb_Arab",
+    "pt": "por_Latn",
+    "ru": "rus_Cyrl",
+}
+
+MODEL_ID   = "facebook/nllb-200-distilled-600M"
+MAX_LENGTH = 512
+
+
+class Translator:
+    def __init__(self):
+        self._pipeline  = None
+        self._tokenizer = None
+        self._model     = None
+        print(f"[Translator] Loading {MODEL_ID}...")
+        self._init_nllb()
+
+    # ----------------------------------------------------------------
+    # Public
+    # ----------------------------------------------------------------
+    def translate(self, text: str, src_lang: str, tgt_lang: str):
+        """
+        Returns (translated_text, method_label).
+        src_lang / tgt_lang are 2-letter codes (en, te, hi, ...).
+        """
+        if not text or not text.strip():
+            return "", "skipped (empty)"
+
+        if self._pipeline is not None or self._model is not None:
+            try:
+                return self._translate_nllb(text, src_lang, tgt_lang)
+            except Exception as e:
+                logger.warning(f"[Translator] NLLB failed ({e}), trying Google...")
+
+        return self._translate_google(text, src_lang, tgt_lang)
+
+    # ----------------------------------------------------------------
+    # NLLB-200
+    # ----------------------------------------------------------------
+    def _init_nllb(self):
+        try:
+            from transformers import pipeline as hf_pipeline
+            self._pipeline = hf_pipeline(
+                "translation",
+                model=MODEL_ID,
+                device_map="auto",
+                max_length=MAX_LENGTH,
+            )
+            print("[Translator] NLLB-200-distilled-600M loaded via pipeline")
+        except Exception as e:
+            logger.warning(f"[Translator] pipeline init failed, trying manual load: {e}")
+            self._init_nllb_manual()
+
+    def _init_nllb_manual(self):
+        try:
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+            import torch
+            self._tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+            self._model = AutoModelForSeq2SeqLM.from_pretrained(
+                MODEL_ID,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            )
+            if torch.cuda.is_available():
+                self._model = self._model.cuda()
+            self._model.eval()
+            print("[Translator] NLLB-200 loaded manually")
+        except Exception as e:
+            logger.error(f"[Translator] NLLB manual load also failed: {e}")
+            self._model = None
+
+    def _translate_nllb(self, text: str, src_lang: str, tgt_lang: str):
+        t0 = time.time()
+        src_code = NLLB_CODES.get(src_lang, "eng_Latn")
+        tgt_code = NLLB_CODES.get(tgt_lang, "tel_Telu")
+
+        if self._pipeline is not None:
+            result     = self._pipeline(
+                text,
+                src_lang=src_code,
+                tgt_lang=tgt_code,
+                max_length=MAX_LENGTH,
+            )
+            translated = result[0]["translation_text"]
+        else:
+            import torch
+            inputs = self._tokenizer(
+                text,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=MAX_LENGTH,
+            )
+            if torch.cuda.is_available():
+                inputs = {k: v.cuda() for k, v in inputs.items()}
+
+            tgt_lang_id = self._tokenizer.convert_tokens_to_ids(tgt_code)
+            with torch.no_grad():
+                output_ids = self._model.generate(
+                    **inputs,
+                    forced_bos_token_id=tgt_lang_id,
+                    max_length=MAX_LENGTH,
+                    num_beams=4,
+                    early_stopping=True,
+                )
+            translated = self._tokenizer.batch_decode(
+                output_ids, skip_special_tokens=True
+            )[0]
+
+        elapsed = time.time() - t0
+        logger.info(f"[Translator] NLLB done in {elapsed:.2f}s: {src_code} -> {tgt_code}")
+        return translated, "NLLB-200-distilled-600M"
+
+    # ----------------------------------------------------------------
+    # Google Translate fallback
+    # ----------------------------------------------------------------
+    def _translate_google(self, text: str, src_lang: str, tgt_lang: str):
+        t0 = time.time()
+        try:
+            from deep_translator import GoogleTranslator
+            translated = GoogleTranslator(
+                source=src_lang if src_lang != "auto" else "auto",
+                target=tgt_lang,
+            ).translate(text)
+            logger.info(f"[Translator] Google done in {time.time()-t0:.2f}s")
+            return translated, "Google Translate (fallback)"
+        except Exception as e:
+            logger.error(f"[Translator] Google fallback also failed: {e}")
+            return f"[Translation failed: {str(e)}]", "error"