Spaces:

MinaNasser
/

Transcriper_API

Runtime error

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>TRANSCRIBE — Live Audio</title>
+  <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@300;400;600&family=Barlow+Condensed:wght@300;500;700&display=swap" rel="stylesheet" />
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    :root {
+      --bg:       #0a0a0a;
+      --surface:  #111111;
+      --border:   #222222;
+      --accent:   #e8ff47;
+      --accent2:  #ff4747;
+      --text:     #d4d4d4;
+      --muted:    #555;
+      --mono:     'IBM Plex Mono', monospace;
+      --display:  'Barlow Condensed', sans-serif;
+    }
+    body {
+      background: var(--bg);
+      color: var(--text);
+      font-family: var(--mono);
+      font-size: 13px;
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+    }
+    /* ── Header ── */
+    header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 18px 32px;
+      border-bottom: 1px solid var(--border);
+      position: sticky;
+      top: 0;
+      background: var(--bg);
+      z-index: 10;
+    }
+    .logo {
+      font-family: var(--display);
+      font-weight: 700;
+      font-size: 26px;
+      letter-spacing: 6px;
+      color: #fff;
+      text-transform: uppercase;
+    }
+    .logo span { color: var(--accent); }
+    .status-pill {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      font-size: 11px;
+      letter-spacing: 2px;
+      text-transform: uppercase;
+      color: var(--muted);
+    }
+    .dot {
+      width: 8px; height: 8px;
+      border-radius: 50%;
+      background: var(--muted);
+      transition: background 0.3s, box-shadow 0.3s;
+    }
+    .dot.live  { background: var(--accent2); box-shadow: 0 0 8px var(--accent2); }
+    .dot.ready { background: var(--accent);  box-shadow: 0 0 8px var(--accent); }
+    /* ── Main layout ── */
+    main {
+      display: grid;
+      grid-template-columns: 340px 1fr;
+      flex: 1;
+      overflow: hidden;
+    }
+    /* ── Sidebar ── */
+    aside {
+      border-right: 1px solid var(--border);
+      padding: 28px 24px;
+      display: flex;
+      flex-direction: column;
+      gap: 28px;
+      overflow-y: auto;
+    }
+    .section-label {
+      font-size: 10px;
+      letter-spacing: 3px;
+      text-transform: uppercase;
+      color: var(--muted);
+      margin-bottom: 10px;
+    }
+    /* Input */
+    .field { display: flex; flex-direction: column; gap: 6px; }
+    label  { font-size: 10px; letter-spacing: 2px; text-transform: uppercase; color: var(--muted); }
+    input[type="text"] {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      color: var(--text);
+      font-family: var(--mono);
+      font-size: 13px;
+      padding: 10px 14px;
+      outline: none;
+      transition: border-color 0.2s;
+      width: 100%;
+    }
+    input[type="text"]:focus { border-color: var(--accent); }
+    /* Buttons */
+    .btn {
+      font-family: var(--display);
+      font-weight: 700;
+      font-size: 15px;
+      letter-spacing: 3px;
+      text-transform: uppercase;
+      border: none;
+      cursor: pointer;
+      padding: 12px 20px;
+      transition: all 0.15s;
+      width: 100%;
+    }
+    .btn-primary {
+      background: var(--accent);
+      color: #000;
+    }
+    .btn-primary:hover  { background: #fff; }
+    .btn-primary:active { transform: scale(0.98); }
+    .btn-danger {
+      background: transparent;
+      color: var(--accent2);
+      border: 1px solid var(--accent2);
+    }
+    .btn-danger:hover { background: var(--accent2); color: #fff; }
+    .btn-ghost {
+      background: transparent;
+      color: var(--text);
+      border: 1px solid var(--border);
+      font-size: 12px;
+    }
+    .btn-ghost:hover { border-color: var(--text); }
+    .btn:disabled {
+      opacity: 0.35;
+      cursor: not-allowed;
+    }
+    /* Upload */
+    .upload-zone {
+      border: 1px dashed var(--border);
+      padding: 24px 16px;
+      text-align: center;
+      cursor: pointer;
+      transition: border-color 0.2s, background 0.2s;
+      position: relative;
+    }
+    .upload-zone:hover { border-color: var(--accent); background: rgba(232,255,71,0.03); }
+    .upload-zone input { position: absolute; inset: 0; opacity: 0; cursor: pointer; }
+    .upload-zone .icon { font-size: 28px; margin-bottom: 8px; }
+    .upload-zone p { color: var(--muted); font-size: 11px; line-height: 1.7; }
+    .upload-zone .filename { color: var(--accent); margin-top: 6px; font-size: 11px; }
+    /* Visualizer */
+    .viz-wrap {
+      border: 1px solid var(--border);
+      height: 64px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      overflow: hidden;
+      background: var(--surface);
+    }
+    canvas#viz { width: 100%; height: 100%; display: block; }
+    /* Chunk counter */
+    .stats-row {
+      display: flex;
+      justify-content: space-between;
+      border: 1px solid var(--border);
+      padding: 12px 16px;
+    }
+    .stat { display: flex; flex-direction: column; gap: 2px; align-items: center; }
+    .stat-val { font-family: var(--display); font-size: 22px; font-weight: 700; color: var(--accent); }
+    .stat-key { font-size: 9px; letter-spacing: 2px; text-transform: uppercase; color: var(--muted); }
+    /* ── Transcript panel ── */
+    .transcript-panel {
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+    .panel-toolbar {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 16px 28px;
+      border-bottom: 1px solid var(--border);
+      gap: 12px;
+    }
+    .panel-toolbar h2 {
+      font-family: var(--display);
+      font-size: 18px;
+      font-weight: 500;
+      letter-spacing: 4px;
+      text-transform: uppercase;
+      color: #fff;
+    }
+    .toolbar-actions { display: flex; gap: 8px; }
+    .toolbar-actions .btn { width: auto; padding: 8px 16px; font-size: 11px; }
+    #transcript-container {
+      flex: 1;
+      overflow-y: auto;
+      padding: 28px;
+      display: flex;
+      flex-direction: column;
+      gap: 14px;
+    }
+    .empty-state {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+      color: var(--muted);
+    }
+    .empty-state .big-icon { font-size: 48px; opacity: 0.3; }
+    .empty-state p { font-size: 11px; letter-spacing: 2px; text-transform: uppercase; }
+    /* Transcript entry */
+    .entry {
+      display: grid;
+      grid-template-columns: 52px 1fr auto;
+      gap: 16px;
+      align-items: start;
+      padding: 16px;
+      border: 1px solid var(--border);
+      background: var(--surface);
+      animation: slideIn 0.25s ease;
+      transition: border-color 0.2s;
+    }
+    .entry:hover { border-color: #333; }
+    @keyframes slideIn {
+      from { opacity: 0; transform: translateY(6px); }
+      to   { opacity: 1; transform: translateY(0); }
+    }
+    .entry-chunk {
+      font-family: var(--display);
+      font-size: 28px;
+      font-weight: 700;
+      color: var(--border);
+      line-height: 1;
+      text-align: right;
+      padding-top: 2px;
+    }
+    .entry-body { display: flex; flex-direction: column; gap: 4px; }
+    .entry-text { color: #e8e8e8; line-height: 1.65; font-size: 13px; }
+    .entry-meta { display: flex; gap: 10px; color: var(--muted); font-size: 10px; letter-spacing: 1px; }
+    .lang-badge {
+      background: #1a1a1a;
+      border: 1px solid var(--border);
+      padding: 2px 8px;
+      font-size: 10px;
+      letter-spacing: 1px;
+      text-transform: uppercase;
+      color: var(--accent);
+    }
+    .entry-time {
+      font-size: 10px;
+      color: var(--muted);
+      white-space: nowrap;
+      letter-spacing: 1px;
+      padding-top: 3px;
+    }
+    /* Error toast */
+    #toast {
+      position: fixed;
+      bottom: 28px;
+      right: 28px;
+      background: var(--accent2);
+      color: #fff;
+      padding: 12px 20px;
+      font-size: 12px;
+      letter-spacing: 1px;
+      display: none;
+      z-index: 100;
+      max-width: 340px;
+    }
+    /* Scrollbar */
+    ::-webkit-scrollbar { width: 4px; }
+    ::-webkit-scrollbar-track { background: transparent; }
+    ::-webkit-scrollbar-thumb { background: var(--border); }
+    /* REC pulse */
+    @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:0.3} }
+    .pulsing { animation: pulse 1s infinite; }
+    @media (max-width: 768px) {
+      main { grid-template-columns: 1fr; }
+      aside { border-right: none; border-bottom: 1px solid var(--border); }
+    }
+  </style>
+</head>
+<body>
+<header>
+  <div class="logo">Trans<span>·</span>cribe</div>
+  <div class="status-pill">
+    <div class="dot" id="status-dot"></div>
+    <span id="status-text">IDLE</span>
+  </div>
+</header>
+<main>
+  <!-- ── Sidebar ── -->
+  <aside>
+    <!-- Session -->
+    <div>
+      <div class="section-label">Session</div>
+      <div class="field" style="margin-bottom:10px">
+        <label for="session-input">Session ID</label>
+        <input type="text" id="session-input" placeholder="auto-generated" />
+      </div>
+    </div>
+    <!-- Live Recording -->
+    <div>
+      <div class="section-label">Live Recording</div>
+      <div class="viz-wrap" style="margin-bottom:10px">
+        <canvas id="viz"></canvas>
+      </div>
+      <div class="stats-row" style="margin-bottom:12px">
+        <div class="stat">
+          <div class="stat-val" id="chunk-count">0</div>
+          <div class="stat-key">Chunks</div>
+        </div>
+        <div class="stat">
+          <div class="stat-val" id="word-count">0</div>
+          <div class="stat-key">Words</div>
+        </div>
+        <div class="stat">
+          <div class="stat-val" id="duration">0s</div>
+          <div class="stat-key">Duration</div>
+        </div>
+      </div>
+      <button class="btn btn-primary" id="btn-record">▶ START RECORDING</button>
+      <div style="height:8px"></div>
+      <button class="btn btn-danger" id="btn-stop" disabled>■ STOP</button>
+    </div>
+    <!-- File Upload -->
+    <div>
+      <div class="section-label">File Upload</div>
+      <div class="upload-zone" id="upload-zone">
+        <input type="file" id="file-input" accept="audio/*,video/*" />
+        <div class="icon">⬆</div>
+        <p>Drop audio file here<br/>or click to browse</p>
+        <div class="filename" id="file-name"></div>
+      </div>
+      <div style="height:10px"></div>
+      <button class="btn btn-ghost" id="btn-upload" disabled>TRANSCRIBE FILE</button>
+    </div>
+    <!-- Clear -->
+    <div style="margin-top:auto">
+      <button class="btn btn-ghost" id="btn-clear">CLEAR TRANSCRIPT</button>
+    </div>
+  </aside>
+  <!-- ── Transcript Panel ── -->
+  <section class="transcript-panel">
+    <div class="panel-toolbar">
+      <h2>Transcript</h2>
+      <div class="toolbar-actions">
+        <button class="btn btn-ghost" id="btn-copy">COPY ALL</button>
+        <button class="btn btn-ghost" id="btn-export">EXPORT .TXT</button>
+      </div>
+    </div>
+    <div id="transcript-container">
+      <div class="empty-state" id="empty-state">
+        <div class="big-icon">🎙</div>
+        <p>Start recording or upload a file</p>
+      </div>
+    </div>
+  </section>
+</main>
+<div id="toast"></div>
+<script>
+  // ── Config ──────────────────────────────────────────────────────────────
+  // Point these at your FastAPI server — change the port if needed (default uvicorn: 8000)
+  const API_HOST = `${window.location.hostname}:6060`;
+  const BASE_URL = `http://${API_HOST}`;
+  const WS_BASE  = `ws://${API_HOST}`;
+  const APP_PATH = '/IntegraAI/voiceapi';
+  // ── State ────────────────────────────────────────────────────────────────
+  let ws = null;
+  let mediaRecorder = null;
+  let audioCtx = null, analyser = null, animId = null;
+  let chunkNumber  = 0;
+  let wordCount    = 0;
+  let recSeconds   = 0;
+  let timerHandle  = null;
+  let entries      = [];
+  // ── DOM refs ─────────────────────────────────────────────────────────────
+  const sessionInput   = document.getElementById('session-input');
+  const btnRecord      = document.getElementById('btn-record');
+  const btnStop        = document.getElementById('btn-stop');
+  const btnUpload      = document.getElementById('btn-upload');
+  const btnClear       = document.getElementById('btn-clear');
+  const btnCopy        = document.getElementById('btn-copy');
+  const btnExport      = document.getElementById('btn-export');
+  const fileInput      = document.getElementById('file-input');
+  const fileName       = document.getElementById('file-name');
+  const container      = document.getElementById('transcript-container');
+  const emptyState     = document.getElementById('empty-state');
+  const statusDot      = document.getElementById('status-dot');
+  const statusText     = document.getElementById('status-text');
+  const chunkEl        = document.getElementById('chunk-count');
+  const wordEl         = document.getElementById('word-count');
+  const durationEl     = document.getElementById('duration');
+  const canvas         = document.getElementById('viz');
+  const ctx2d          = canvas.getContext('2d');
+  const toast          = document.getElementById('toast');
+  // ── Helpers ───────────────────────────────────────────────────────────────
+  function genSessionId() {
+    return 'ses_' + Math.random().toString(36).slice(2, 10);
+  }
+  function setStatus(state) {
+    statusDot.className = 'dot';
+    if (state === 'live')  { statusDot.classList.add('live');  statusText.textContent = 'RECORDING'; statusDot.classList.add('pulsing'); }
+    if (state === 'ready') { statusDot.classList.add('ready'); statusText.textContent = 'CONNECTED'; }
+    if (state === 'idle')  { statusText.textContent = 'IDLE'; }
+    if (state === 'busy')  { statusText.textContent = 'PROCESSING'; }
+  }
+  function showToast(msg, duration = 4000) {
+    toast.textContent = msg;
+    toast.style.display = 'block';
+    clearTimeout(toast._t);
+    toast._t = setTimeout(() => toast.style.display = 'none', duration);
+  }
+  function addEntry(chunk, text, language, time) {
+    emptyState.style.display = 'none';
+    entries.push({ chunk, text, language, time });
+    const words = text.trim().split(/\s+/).length;
+    wordCount += words;
+    wordEl.textContent = wordCount;
+    const el = document.createElement('div');
+    el.className = 'entry';
+    el.innerHTML = `
+      <div class="entry-chunk">${String(chunk).padStart(2,'0')}</div>
+      <div class="entry-body">
+        <div class="entry-text">${escapeHtml(text)}</div>
+        <div class="entry-meta">
+          <span class="lang-badge">${language || '??'}</span>
+          <span>${words} word${words !== 1 ? 's' : ''}</span>
+        </div>
+      </div>
+      <div class="entry-time">${time}</div>
+    `;
+    container.appendChild(el);
+    container.scrollTop = container.scrollHeight;
+  }
+  function escapeHtml(s) {
+    return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+  }
+  function nowTime() {
+    return new Date().toLocaleTimeString('en-US', { hour12: false });
+  }
+  // ── Visualizer ────────────────────────────────────────────────────────────
+  function startViz(stream) {
+    if (!audioCtx) audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+    analyser = audioCtx.createAnalyser();
+    analyser.fftSize = 128;
+    audioCtx.createMediaStreamSource(stream).connect(analyser);
+    const buf = new Uint8Array(analyser.frequencyBinCount);
+    function draw() {
+      animId = requestAnimationFrame(draw);
+      canvas.width  = canvas.offsetWidth;
+      canvas.height = canvas.offsetHeight;
+      analyser.getByteFrequencyData(buf);
+      ctx2d.clearRect(0, 0, canvas.width, canvas.height);
+      const bw = canvas.width / buf.length;
+      buf.forEach((v, i) => {
+        const h = (v / 255) * canvas.height;
+        ctx2d.fillStyle = `rgba(232,255,71,${0.3 + (v/255)*0.7})`;
+        ctx2d.fillRect(i * bw, canvas.height - h, bw - 1, h);
+      });
+    }
+    draw();
+  }
+  function stopViz() {
+    if (animId) cancelAnimationFrame(animId);
+    ctx2d.clearRect(0, 0, canvas.width, canvas.height);
+  }
+  // ── WebSocket recording ────────────────────────────────────────────────────
+  async function startRecording() {
+    const sessionId = sessionInput.value.trim() || genSessionId();
+    sessionInput.value = sessionId;
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      // WebSocket
+      ws = new WebSocket(`${WS_BASE}${APP_PATH}/ws/${sessionId}`);
+      ws.binaryType = 'arraybuffer';
+      ws.onopen = () => {
+        setStatus('live');
+        btnRecord.disabled = true;
+        btnStop.disabled   = false;
+        chunkNumber = 0; recSeconds = 0;
+        const CHUNK_MS = 10000; // 10 seconds per chunk
+        function startChunk() {
+          if (ws.readyState !== WebSocket.OPEN) return;
+          const chunks = [];
+          mediaRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
+          mediaRecorder.ondataavailable = (e) => {
+            if (e.data.size > 0) chunks.push(e.data);
+          };
+          mediaRecorder.onstop = () => {
+            if (chunks.length && ws.readyState === WebSocket.OPEN) {
+              // Complete WebM per cycle: own EBML header, timestamps reset to 0
+              const blob = new Blob(chunks, { type: 'audio/webm' });
+              ws.send(blob);
+              chunkNumber++;
+              chunkEl.textContent = chunkNumber;
+            }
+            if (ws.readyState === WebSocket.OPEN) startChunk();
+          };
+          mediaRecorder.start();
+          setTimeout(() => {
+            if (mediaRecorder.state === 'recording') mediaRecorder.stop();
+          }, CHUNK_MS);
+        }
+        startChunk();
+        timerHandle = setInterval(() => {
+          recSeconds++;
+          durationEl.textContent = recSeconds < 60
+            ? recSeconds + 's'
+            : Math.floor(recSeconds/60) + 'm' + (recSeconds%60) + 's';
+        }, 1000);
+        startViz(stream);
+      };
+      ws.onmessage = (e) => {
+        const data = JSON.parse(e.data);
+        if (data.error) { showToast('Server: ' + data.error); return; }
+        addEntry(data.chunk_number, data.text, data.language, nowTime());
+      };
+      ws.onerror = () => showToast('WebSocket error — check server.');
+      ws.onclose = () => { setStatus('idle'); };
+    } catch (err) {
+      showToast('Microphone access denied or unavailable.');
+    }
+  }
+  function stopRecording() {
+    if (ws) ws.close();          // close WS first so onstop doesn't start a new chunk
+    if (mediaRecorder && mediaRecorder.state !== 'inactive') mediaRecorder.stop();
+    clearInterval(timerHandle);
+    stopViz();
+    setStatus('idle');
+    btnRecord.disabled = false;
+    btnStop.disabled   = true;
+  }
+  // ── File upload ────────────────────────────────────────────────────────────
+  fileInput.addEventListener('change', () => {
+    if (fileInput.files.length > 0) {
+      fileName.textContent  = fileInput.files[0].name;
+      btnUpload.disabled    = false;
+    }
+  });
+  btnUpload.addEventListener('click', async () => {
+    if (!fileInput.files.length) return;
+    const file      = fileInput.files[0];
+    const sessionId = sessionInput.value.trim() || genSessionId();
+    sessionInput.value = sessionId;
+    const form = new FormData();
+    form.append('file', file);
+    form.append('session_id', sessionId);
+    form.append('chunk_number', '0');
+    btnUpload.disabled = true;
+    btnUpload.textContent = 'UPLOADING…';
+    setStatus('busy');
+    try {
+      const resp = await fetch(`${BASE_URL}${APP_PATH}/transcribe`, { method: 'POST', body: form });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const data = await resp.json();
+      addEntry(data.chunk_number, data.text, data.language, nowTime());
+      setStatus('idle');
+    } catch (err) {
+      showToast('Upload failed: ' + err.message);
+      setStatus('idle');
+    } finally {
+      btnUpload.textContent = 'TRANSCRIBE FILE';
+      btnUpload.disabled    = false;
+    }
+  });
+  // ── Controls ──────────────────────────────────────────────────────────────
+  btnRecord.addEventListener('click', startRecording);
+  btnStop.addEventListener('click', stopRecording);
+  btnClear.addEventListener('click', () => {
+    entries = []; wordCount = 0; chunkNumber = 0; recSeconds = 0;
+    wordEl.textContent = '0'; chunkEl.textContent = '0'; durationEl.textContent = '0s';
+    container.innerHTML = '';
+    container.appendChild(emptyState);
+    emptyState.style.display = '';
+  });
+  btnCopy.addEventListener('click', () => {
+    const text = entries.map(e => `[${e.time}][${e.language}] ${e.text}`).join('\n');
+    navigator.clipboard.writeText(text).then(() => showToast('Copied to clipboard!', 2000));
+  });
+  btnExport.addEventListener('click', () => {
+    const text = entries.map(e => `[Chunk ${e.chunk}][${e.time}][${e.language}]\n${e.text}\n`).join('\n');
+    const blob = new Blob([text], { type: 'text/plain' });
+    const a    = document.createElement('a');
+    a.href     = URL.createObjectURL(blob);
+    a.download = `transcript_${sessionInput.value || 'session'}.txt`;
+    a.click();
+  });
+  // ── Auto-generate session on load ─────────────────────────────────────────
+  sessionInput.value = genSessionId();
+</script>
+</body>
+</html>

CustomSTT_COLAB.ipynb ADDED Viewed

	@@ -0,0 +1,259 @@

+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Run First two cells only"
+      ],
+      "metadata": {
+        "id": "jRmIrf0il4AC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ── 1. Install dependencies ───────────────────────────────────────────────────\n",
+        "!pip install -q fastapi uvicorn python-multipart pyngrok faster-whisper\n",
+        "\n",
+        "# ── 2. Imports ────────────────────────────────────────────────────────────────\n",
+        "import os\n",
+        "import asyncio\n",
+        "import tempfile\n",
+        "import threading\n",
+        "import time\n",
+        "import functools\n",
+        "import logging\n",
+        "\n",
+        "from fastapi import FastAPI, File, UploadFile, HTTPException\n",
+        "from fastapi.responses import JSONResponse\n",
+        "import uvicorn\n",
+        "from faster_whisper import WhisperModel\n",
+        "from faster_whisper.audio import decode_audio\n",
+        "from pyngrok import ngrok\n",
+        "\n",
+        "# ── 3. Logging setup ─────────────────────────────────────────────────────────\n",
+        "LOG_FILE = \"/content/stt_server.log\"\n",
+        "\n",
+        "for handler in logging.root.handlers[:]:\n",
+        "    logging.root.removeHandler(handler)\n",
+        "\n",
+        "logging.basicConfig(\n",
+        "    level=logging.INFO,\n",
+        "    format=\"%(asctime)s [%(levelname)s] %(message)s\",\n",
+        "    handlers=[\n",
+        "        logging.FileHandler(LOG_FILE),\n",
+        "        logging.StreamHandler()\n",
+        "    ],\n",
+        "    force=True      # ← overrides uvicorn's logger hijack\n",
+        ")\n",
+        "logger = logging.getLogger(__name__)\n",
+        "\n",
+        "# ── 4. Ngrok auth ─────────────────────────────────────────────────────────────\n",
+        "ngrok.set_auth_token(\"3491amoA7gGNvQYJDLUYwNdlTqu_83s75o2cESPNrWdfhTDBN\")\n",
+        "\n",
+        "# ── 5. Load both models ───────────────────────────────────────────────────────\n",
+        "logger.info(\"Loading Arabic model...\")\n",
+        "arabic_model = WhisperModel(\"MinaNasser/Whisper-Small-MN-int8\", compute_type=\"int8\", device=\"cuda\")\n",
+        "\n",
+        "logger.info(\"Loading English model...\")\n",
+        "english_model = WhisperModel(\"Systran/faster-whisper-large-v3\", compute_type=\"int8\", device=\"cuda\")\n",
+        "\n",
+        "logger.info(\"✅ Both models loaded.\")\n",
+        "\n",
+        "# ── 6. FastAPI app ────────────────────────────────────────────────────────────\n",
+        "app = FastAPI(title=\"Custom Arabic/English STT\")\n",
+        "\n",
+        "@app.get(\"/health\")\n",
+        "async def health():\n",
+        "    return {\"status\": \"ok\", \"models\": [\"arabic\", \"english\"]}\n",
+        "\n",
+        "@app.post(\"/transcribe\")\n",
+        "async def transcribe(file: UploadFile = File(...)):\n",
+        "    with tempfile.NamedTemporaryFile(delete=False, suffix=\".wav\") as tmp:\n",
+        "        tmp.write(await file.read())\n",
+        "        tmp_path = tmp.name\n",
+        "\n",
+        "    try:\n",
+        "        loop = asyncio.get_event_loop()\n",
+        "\n",
+        "        # ── Step 1: detect language\n",
+        "        def detect():\n",
+        "            waveform = decode_audio(tmp_path)\n",
+        "            language, probability, _ = english_model.detect_language(waveform)\n",
+        "            return language, probability\n",
+        "\n",
+        "        language, probability = await loop.run_in_executor(None, detect)\n",
+        "        logger.info(f\"Detected language: {language} ({probability:.2f})\")\n",
+        "\n",
+        "        # ── Step 2: route to correct model\n",
+        "        if language == \"ar\":\n",
+        "            logger.info(f\"used OUR MODEL\")\n",
+        "            fn = functools.partial(arabic_model.transcribe, tmp_path, language=\"ar\",vad_filter=True)\n",
+        "        else:\n",
+        "            logger.info(f\"used ENG MODEL\")\n",
+        "            fn = functools.partial(english_model.transcribe, tmp_path, language=language,vad_filter=True)\n",
+        "\n",
+        "        segments, info = await loop.run_in_executor(None, fn)\n",
+        "        transcript = \" \".join(seg.text for seg in segments)\n",
+        "\n",
+        "        logger.info(f\"Transcript [{info.language}]: {transcript[:80]}...\")\n",
+        "\n",
+        "        return JSONResponse(content={\n",
+        "            \"text\": transcript,\n",
+        "            \"language\": info.language,\n",
+        "            \"language_probability\": info.language_probability,\n",
+        "        })\n",
+        "    except Exception as e:\n",
+        "        logger.error(f\"Transcription failed: {e}\")\n",
+        "        raise HTTPException(status_code=500, detail=str(e))\n",
+        "    finally:\n",
+        "        if os.path.exists(tmp_path):\n",
+        "            os.unlink(tmp_path)\n",
+        "\n",
+        "# ── 7. Cleanup & start server ─────────────────────────────────────────────────\n",
+        "try:\n",
+        "    ngrok.kill()\n",
+        "except Exception:\n",
+        "    pass\n",
+        "\n",
+        "!fuser -k 8000/tcp || true\n",
+        "time.sleep(1)\n",
+        "\n",
+        "def run_server():\n",
+        "    uvicorn.run(app, host=\"0.0.0.0\", port=8000, log_level=\"info\", log_config=None)\n",
+        "\n",
+        "thread = threading.Thread(target=run_server, daemon=True)\n",
+        "thread.start()\n",
+        "time.sleep(5)\n",
+        "\n",
+        "# ── 8. Expose via ngrok ───────────────────────────────────────────────────────\n",
+        "public_url = ngrok.connect(8000).public_url\n",
+        "logger.info(f\"Public URL: {public_url}\")\n",
+        "print(f\"\\n Public URL : {public_url}\")\n",
+        "print(f\"   Health check: {public_url}/health\")\n",
+        "print(f\"   Transcribe  : {public_url}/transcribe\")\n",
+        "print(f\"\\n Set CUSTOM_STT_URL={public_url}\")"
+      ],
+      "metadata": {
+        "id": "CETOGHw9ZIzs"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!tail -f /content/stt_server.log"
+      ],
+      "metadata": {
+        "id": "INTTVax9ZLYO"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ── 1. Install dependencies ───────────────────────────────────────────────────\n",
+        "!pip install -q fastapi uvicorn python-multipart pyngrok faster-whisper\n",
+        "\n",
+        "# ── 2. Imports ────────────────────────────────────────────────────────────────\n",
+        "import os\n",
+        "import asyncio\n",
+        "import tempfile\n",
+        "import threading\n",
+        "import time\n",
+        "import functools\n",
+        "\n",
+        "from fastapi import FastAPI, File, UploadFile, HTTPException\n",
+        "from fastapi.responses import JSONResponse\n",
+        "import uvicorn\n",
+        "from faster_whisper import WhisperModel\n",
+        "from pyngrok import ngrok\n",
+        "\n",
+        "# ── 3. Ngrok auth ─────────────────────────────────────────────────────────────\n",
+        "ngrok.set_auth_token(\"3491amoA7gGNvQYJDLUYwNdlTqu_83s75o2cESPNrWdfhTDBN\")\n",
+        "\n",
+        "# ── 4. Load model ─────────────────────────────────────────────────────────────\n",
+        "MODEL_NAME = \"Systran/faster-whisper-large-v3\"\n",
+        "#MODEL_NAME = \"MinaNasser/Whisper-Base-MN-EG-int8\"\n",
+        "#MODEL_NAME = \"MinaNasser/Whisper-Small-MN-int8\"\n",
+        "model = WhisperModel(MODEL_NAME, compute_type=\"int8\", device=\"cuda\")\n",
+        "\n",
+        "# ── 5. FastAPI app ────────────────────────────────────────────────────────────\n",
+        "app = FastAPI(title=\"Custom Arabic STT\")\n",
+        "\n",
+        "@app.get(\"/health\")\n",
+        "async def health():\n",
+        "    return {\"status\": \"ok\"}\n",
+        "\n",
+        "@app.post(\"/transcribe\")\n",
+        "async def transcribe(file: UploadFile = File(...)):\n",
+        "    with tempfile.NamedTemporaryFile(delete=False, suffix=\".wav\") as tmp:\n",
+        "        tmp.write(await file.read())\n",
+        "        tmp_path = tmp.name\n",
+        "\n",
+        "    try:\n",
+        "        loop = asyncio.get_event_loop()\n",
+        "        # functools.partial lets us pass keyword args through run_in_executor\n",
+        "        fn = functools.partial(model.transcribe, tmp_path) #, language=\"ar\"\n",
+        "        segments, info = await loop.run_in_executor(None, fn)\n",
+        "        transcript = \" \".join(seg.text for seg in segments)\n",
+        "        return JSONResponse(content={\n",
+        "            \"text\": transcript,\n",
+        "            \"language\": info.language,\n",
+        "            \"language_probability\": info.language_probability,\n",
+        "        })\n",
+        "    except Exception as e:\n",
+        "        raise HTTPException(status_code=500, detail=str(e))\n",
+        "    finally:\n",
+        "        if os.path.exists(tmp_path):\n",
+        "            os.unlink(tmp_path)\n",
+        "\n",
+        "# ── 6. Cleanup & start server ─────────────────────────────────────────────────\n",
+        "try:\n",
+        "    ngrok.kill()\n",
+        "except Exception:\n",
+        "    pass\n",
+        "\n",
+        "!fuser -k 8000/tcp || true\n",
+        "time.sleep(1)\n",
+        "\n",
+        "def run_server():\n",
+        "    uvicorn.run(app, host=\"0.0.0.0\", port=8000, log_level=\"info\")\n",
+        "\n",
+        "thread = threading.Thread(target=run_server, daemon=True)\n",
+        "thread.start()\n",
+        "time.sleep(5)  # wait for server to be ready\n",
+        "\n",
+        "# ── 7. Expose via ngrok ───────────────────────────────────────────────────────\n",
+        "public_url = ngrok.connect(8000).public_url\n",
+        "print(f\"\\n Public URL : {public_url}\")\n",
+        "print(f\"   Health check: {public_url}/health\")\n",
+        "print(f\"   Transcribe  : {public_url}/transcribe\")\n",
+        "print(f\"\\n Set CUSTOM_STT_URL={public_url}  (no trailing slash, no /transcribe)\")"
+      ],
+      "metadata": {
+        "id": "QupX525ER_Kw"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Dockerfile ADDED Viewed

	@@ -0,0 +1,24 @@

+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    libsndfile1 \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+# HF Spaces runs as a non-root user, this avoids permission issues
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /home/user/app
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user . .
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

configs.py ADDED Viewed

	@@ -0,0 +1,28 @@

+from pydantic_settings import BaseSettings, SettingsConfigDict
+class Settings(BaseSettings):
+    APP_NAME: str
+    APP_VERSION: str
+    APP_VARIENT: str
+    INFERENCE_TYPE:str ="local"   # local or remote
+    DATABASE_URL:str ="sqlite+aiosqlite:///./app.db"
+    LOCAL_INFERENCE_MODEL_SIZE:str ="small"   # small , base
+    REMOTE_INFERENCE_PROVIDER:str ="mistral"   # mistral , groq
+    MISTRAL_MODEL:str="voxtral-mini-latest"
+    MISTRAL_API_KEY:str
+    GROQ_API_KEY:str
+    GROQ_MODEL:str="whisper-large-v3-turbo"
+    DEEPGRAM_API_KEY:str="0b47e602a9df5a073fa000986aa4ff465d36c3c6"
+    DEEPGRAM_MODEL:str="nova-3"
+    ASSEMBLYAI_API_KEY:str="5efd83b230794b3ebf332b28672dc441"
+    CUSTOM_STT_URL:str = "https://elwanda-agnathous-tragically.ngrok-free.dev/transcribe"   # the URL from Colab
+    class Config:
+        env_file = ".env"
+def get_settings(): ## this makes any got by "get_settings().APP_NAME"
+    return Settings()

controllers/TranscriptionController.py ADDED Viewed

	@@ -0,0 +1,141 @@

+from configs import get_settings
+import asyncio
+# import librosa
+# import numpy as np
+from stores.sttremotes import STTRemoteManager
+from faster_whisper.audio import decode_audio  # handles webm natively
+class TranscriptionController:
+    def __init__(self,models,logger,remotename):
+        self.settings = get_settings()
+        self.models = models
+        self.logger = logger
+        self.remote_max_request_rate=60
+        self.remotename=remotename
+        self.remote=STTRemoteManager(default_provider=remotename) if remotename else None
+    async def transcribe_audio(self,audio_path: str):
+        if self.settings.INFERENCE_TYPE == "local":
+            return await self.transcribe_local(audio_path)
+        elif self.settings.INFERENCE_TYPE == "remote":
+            return await self.transcribe_remote(audio_path)
+        else:
+            raise ValueError(f"Unsupported INFERENCE_TYPE: {self.settings.INFERENCE_TYPE}")
+    async def language_detection(self, audio_path: str):
+        if self.settings.INFERENCE_TYPE == "local":
+            model_size = self.settings.LOCAL_INFERENCE_MODEL_SIZE
+            model = self.models.get(f"{model_size}_english")
+        if not model:
+            raise ValueError(f"Model {model_size}_language_detection not available")
+        print(f"Detecting language for {audio_path} with {model_size} model...")
+        def process():
+            waveform = decode_audio(audio_path)
+            language, probability,_ = model.detect_language(waveform)
+            return language, probability
+        loop = asyncio.get_event_loop()
+        language, language_probability = await loop.run_in_executor(None, process)
+        return language, language_probability
+    async def transcribe_local(self,audio_path: str):
+        language, probability = await self.language_detection(audio_path)
+        if language == "ar":
+            self.logger.info(f"Processing Arabic audio with probability {probability:.2f}")
+            return await self.transcribe_local_arabic(audio_path)
+        elif language == "en":
+            self.logger.info(f"Processing English audio with probability {probability:.2f}")
+            return await self.transcribe_local_english(audio_path)
+        else:
+            self.logger.warning(f"Unsupported language detected: {language}. Skipping transcription.")
+            return None, language
+    async def transcribe_local_arabic(self,audio_path: str):
+        if self.settings.INFERENCE_TYPE == "local":
+            model_size = self.settings.LOCAL_INFERENCE_MODEL_SIZE
+            model=self.models.get(f"{model_size}_arabic")
+        if not model:
+            raise ValueError(f"Model {model_size}_arabic not available")
+        print(f"Transcribing {audio_path} with {model_size} model...")
+        ALLOWED_LANGUAGES = ['ar']
+        def process_with_filter():
+            segments, info = model.transcribe(
+                audio_path,
+                beam_size=5,
+                best_of=5,
+                language="ar",
+                vad_filter=True,
+                vad_parameters=dict(min_silence_duration_ms=500,threshold=0.3)
+            )
+            if info.language not in ALLOWED_LANGUAGES:
+                self.logger.info(f"Skipping: Detected {info.language} with prob {info.language_probability:.2f}")
+                return None, info.language
+            full_text = ""
+            for segment in segments:
+                full_text += segment.text + " "
+            return full_text.strip(), info.language
+        loop = asyncio.get_event_loop()
+        text, language = await loop.run_in_executor(None, process_with_filter)
+        return text, language
+    async def transcribe_local_english(self,audio_path: str):
+        if self.settings.INFERENCE_TYPE == "local":
+            model_size = self.settings.LOCAL_INFERENCE_MODEL_SIZE
+            model=self.models.get(f"{model_size}_english")
+        if not model:
+            raise ValueError(f"Model {model_size}_english not available")
+        print(f"Transcribing {audio_path} with {model_size} model...")
+        ALLOWED_LANGUAGES = ['en']
+        def process_with_filter():
+            segments, info = model.transcribe(
+                audio_path,
+                beam_size=5,
+                best_of=5,
+                language="en",
+                vad_filter=True,
+                vad_parameters=dict(min_silence_duration_ms=500,threshold=0.3)
+            )
+            if info.language not in ALLOWED_LANGUAGES:
+                self.logger.info(f"Skipping: Detected {info.language} with prob {info.language_probability:.2f}")
+                return None, info.language
+            full_text = ""
+            for segment in segments:
+                full_text += segment.text + " "
+            return full_text.strip(), info.language
+        loop = asyncio.get_event_loop()
+        text, language = await loop.run_in_executor(None, process_with_filter)
+        return text, language
+    async def transcribe_remote(self,audio_path: str):
+        if not self.remote:
+            raise ValueError("Remote STT provider not configured")
+        if not hasattr(self, "_last_request_time"):
+            self._last_request_time = 0
+        elapsed = asyncio.get_event_loop().time() - self._last_request_time
+        if elapsed < 1 / self.remote_max_request_rate:
+            await asyncio.sleep((1 / self.remote_max_request_rate) - elapsed)
+        self._last_request_time = asyncio.get_event_loop().time()
+        return await self.remote.transcribe_remote(audio_path,self.remotename)

controllers/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ from .TranscriptionController import TranscriptionController

main.py ADDED Viewed

	@@ -0,0 +1,25 @@

+from fastapi import FastAPI
+import logging
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from routes import base , db , transcripe
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+app = FastAPI(title="Audio Transcription API")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.include_router(base.base_router)
+app.include_router(db.db_router)
+app.include_router(transcripe.transcripe_router)
+# Register DB startup event
+db.register_startup_events(app)
+transcripe.register_startup_events(app)
+transcripe.register_shutdown_events(app)

models/__init__.py ADDED Viewed

File without changes

models/database.py ADDED Viewed

	@@ -0,0 +1,30 @@

+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+from configs import get_settings
+import os
+#DB_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./app.db")
+DB_URL= get_settings().DATABASE_URL
+engine = create_async_engine(DB_URL, echo=True, future=True)
+AsyncSessionLocal = sessionmaker(
+    bind=engine, class_=AsyncSession, expire_on_commit=False
+)
+Base = declarative_base()
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        yield session
+if DB_URL.startswith("sqlite"):
+    @event.listens_for(engine.sync_engine, "connect")
+    def enable_sqlite_fk(dbapi_connection, connection_record):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()

models/sessions.py ADDED Viewed

	@@ -0,0 +1,52 @@

+from sqlalchemy import Column, String, TIMESTAMP
+from sqlalchemy.sql import func
+from .database import Base
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from sqlalchemy.orm import relationship
+class Session(Base):
+    __tablename__ = "sessions"
+    session_id = Column(String, primary_key=True, index=True)
+    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
+    status = Column(String, default="active")
+    transcriptions = relationship(
+        "Transcription",
+        back_populates="session",
+        cascade="all, delete-orphan",
+        passive_deletes=True
+    )
+# CRUD operations
+async def create_session(db: AsyncSession, session_id: str, status: str = "active"):
+    new_session = Session(session_id=session_id, status=status)
+    db.add(new_session)
+    await db.commit()
+    await db.refresh(new_session)
+    return new_session
+async def get_session(db: AsyncSession, session_id: str):
+    result = await db.execute(select(Session).where(Session.session_id == session_id))
+    return result.scalar_one_or_none()
+async def get_all_sessions(db: AsyncSession):
+    result = await db.execute(select(Session))
+    return result.scalars().all()
+async def update_session_status(db: AsyncSession, session_id: str, status: str):
+    session = await get_session(db, session_id)
+    if session:
+        session.status = status
+        await db.commit()
+        await db.refresh(session)
+    return session
+async def delete_session(db: AsyncSession, session_id: str):
+    session = await get_session(db, session_id)
+    if session:
+        await db.delete(session)
+        await db.commit()
+    return session

models/transcriptions.py ADDED Viewed

	@@ -0,0 +1,53 @@

+from sqlalchemy import Column, Integer, String, TIMESTAMP, ForeignKey
+from sqlalchemy.sql import func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from .database import Base
+from sqlalchemy.orm import relationship
+class Transcription(Base):
+    __tablename__ = "transcriptions"
+    id = Column(Integer, primary_key=True, index=True)
+    session_id = Column(String, ForeignKey("sessions.session_id",onupdate='CASCADE',ondelete='CASCADE'))
+    chunk_number = Column(Integer)
+    text = Column(String)
+    language = Column(String)
+    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
+    session = relationship("Session", back_populates="transcriptions")
+# CRUD operations
+async def create_transcription(db: AsyncSession, session_id: str, chunk_number: int, text: str, language: str):
+    new_transcription = Transcription(
+        session_id=session_id,
+        chunk_number=chunk_number,
+        text=text,
+        language=language
+    )
+    db.add(new_transcription)
+    await db.commit()
+    await db.refresh(new_transcription)
+    return new_transcription
+async def get_transcriptions_by_session(db: AsyncSession, session_id: str):
+    result = await db.execute(select(Transcription).where(Transcription.session_id == session_id))
+    return result.scalars().all()
+async def update_transcription_text(db: AsyncSession, transcription_id: int, new_text: str):
+    result = await db.execute(select(Transcription).where(Transcription.id == transcription_id))
+    transcription = result.scalar_one_or_none()
+    if transcription:
+        transcription.text = new_text
+        await db.commit()
+        await db.refresh(transcription)
+    return transcription
+async def delete_transcription(db: AsyncSession, transcription_id: int):
+    result = await db.execute(select(Transcription).where(Transcription.id == transcription_id))
+    transcription = result.scalar_one_or_none()
+    if transcription:
+        await db.delete(transcription)
+        await db.commit()
+    return transcription

requirements.txt ADDED Viewed

	@@ -0,0 +1,15 @@

+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+python-multipart==0.0.6
+faster-whisper==1.2.1
+websockets==12.0
+pydantic-settings==2.13.0
+SQLAlchemy==2.0.46
+aiosqlite==0.22.1
+librosa==0.11.0
+mistralai==1.12.3
+groq==1.0.0
+aiohttp==3.13.3
+assemblyai==0.58.0
+deepgram-sdk==6.0.1
+asyncpg==0.31.0

routes/__init__.py ADDED Viewed

File without changes

routes/base.py ADDED Viewed

	@@ -0,0 +1,20 @@

+from fastapi import APIRouter , Depends
+from configs import Settings , get_settings
+base_router = APIRouter(
+    prefix=f"/{get_settings().APP_NAME}/{get_settings().APP_VARIENT}",
+    tags=["base"])
+@base_router.get("/")
+async def welcome(app_settings: Settings = Depends(get_settings)):
+    app_name = app_settings.APP_NAME
+    app_version = app_settings.APP_VERSION
+    return {"app_name": app_name, "app_version": app_version, "conf":app_settings}
+@base_router.get("/health")
+async def health(app_settings: Settings = Depends(get_settings)):
+    app_name = app_settings.APP_NAME
+    app_version = app_settings.APP_VERSION
+    return {"app_name": app_name, "app_version": app_version , "status": "healthy"}

routes/db.py ADDED Viewed

	@@ -0,0 +1,112 @@

+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List
+from fastapi import FastAPI
+from configs import get_settings
+from models.database import get_db, Base, engine
+from models.sessions import create_session, get_session, update_session_status, delete_session,get_all_sessions
+from models.transcriptions import create_transcription, get_transcriptions_by_session, update_transcription_text, delete_transcription
+db_router = APIRouter(
+        prefix=f"/{get_settings().APP_NAME}/{get_settings().APP_VARIENT}",
+        tags=["db"])
+@db_router.post("/getallsessions/", response_model=List)
+async def api_get_all_session(db: AsyncSession = Depends(get_db)):
+    session = await get_all_sessions(db)
+    sess=[]
+    for se in session:
+        sess.append(
+            {
+                "session_id":se.session_id,
+                "created_at":se.created_at,
+                "status":se.status,
+            })
+    return sess
+    #return {"sessions":f"{sess}"}
+@db_router.post("/sessions/", response_model=dict)
+async def api_create_session(session_id: str, db: AsyncSession = Depends(get_db)):
+    session = await create_session(db, session_id)
+    return {"session_id": session.session_id, "status": session.status, "created_at": session.created_at}
+@db_router.get("/sessions/{session_id}", response_model=dict)
+async def api_get_session(session_id: str, db: AsyncSession = Depends(get_db)):
+    session = await get_session(db, session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return {"session_id": session.session_id, "status": session.status, "created_at": session.created_at}
+@db_router.patch("/sessions/{session_id}", response_model=dict)
+async def api_update_session_status(session_id: str, status: str, db: AsyncSession = Depends(get_db)):
+    session = await update_session_status(db, session_id, status)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return {"session_id": session.session_id, "status": session.status}
+@db_router.delete("/sessions/{session_id}", response_model=dict)
+async def api_delete_session(session_id: str, db: AsyncSession = Depends(get_db)):
+    session = await delete_session(db, session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return {"detail": "Session deleted successfully"}
+@db_router.post("/transcriptions/", response_model=dict)
+async def api_create_transcription(session_id: str, chunk_number: int, text: str, language: str, db: AsyncSession = Depends(get_db)):
+    transcription = await create_transcription(db, session_id, chunk_number, text, language)
+    return {
+        "id": transcription.id,
+        "session_id": transcription.session_id,
+        "chunk_number": transcription.chunk_number,
+        "text": transcription.text,
+        "language": transcription.language,
+        "created_at": transcription.created_at
+    }
+@db_router.get("/transcriptions/{session_id}", response_model=List[dict])
+async def api_get_transcriptions(session_id: str, db: AsyncSession = Depends(get_db)):
+    transcriptions = await get_transcriptions_by_session(db, session_id)
+    if not transcriptions:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return [
+        {
+            "id": t.id,
+            "session_id": t.session_id,
+            "chunk_number": t.chunk_number,
+            "text": t.text,
+            "language": t.language,
+            "created_at": t.created_at
+        } for t in transcriptions
+    ]
+@db_router.patch("/transcriptions/{transcription_id}", response_model=dict)
+async def api_update_transcription(transcription_id: int, new_text: str, db: AsyncSession = Depends(get_db)):
+    transcription = await update_transcription_text(db, transcription_id, new_text)
+    if not transcription:
+        raise HTTPException(status_code=404, detail="Transcription not found")
+    return {
+        "id": transcription.id,
+        "text": transcription.text
+    }
+@db_router.delete("/transcriptions/{transcription_id}", response_model=dict)
+async def api_delete_transcription(transcription_id: int, db: AsyncSession = Depends(get_db)):
+    transcription = await delete_transcription(db, transcription_id)
+    if not transcription:
+        raise HTTPException(status_code=404, detail="Transcription not found")
+    return {"detail": "Transcription deleted successfully"}
+async def init_models():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+def register_startup_events(app: FastAPI):
+    @app.on_event("startup")
+    async def startup_event():
+        await init_models()

routes/transcripe.py ADDED Viewed

	@@ -0,0 +1,133 @@

+from fastapi import APIRouter ,Depends ,FastAPI ,WebSocket, WebSocketDisconnect, UploadFile, File
+from configs import   get_settings
+import os
+import tempfile
+from sqlalchemy.ext.asyncio import AsyncSession
+from faster_whisper import WhisperModel
+import logging
+from controllers.TranscriptionController import TranscriptionController
+import uuid
+from models.sessions import create_session, get_session
+from models.transcriptions import create_transcription
+from models.database import get_db
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+transcripe_router = APIRouter(
+        prefix=f"/{get_settings().APP_NAME}/{get_settings().APP_VARIENT}",
+        tags=["transcripe"])
+@transcripe_router.post("/transcribe")
+async def transcribe_endpoint(file: UploadFile = File(...),session_id: str = None,chunk_number: int = 0, db: AsyncSession = Depends(get_db)):
+    if not session_id or session_id.strip() == "":
+        session_id = f"ses_{uuid.uuid4().hex[:8]}"
+    session = await get_session(db, session_id)
+    if not session:
+        session = await create_session(db, session_id)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
+        content = await file.read()
+        temp_file.write(content)
+        temp_path = temp_file.name
+    try:
+        controller = TranscriptionController(models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER)
+        text, language = await controller.transcribe_audio(temp_path)
+        if text:
+            transcription = await create_transcription(db, session_id, chunk_number, text, language)
+        return {
+            "id": transcription.id,
+            "session_id": transcription.session_id,
+            "chunk_number": transcription.chunk_number,
+            "text": transcription.text,
+            "language": transcription.language,
+            "created_at": transcription.created_at
+        }
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+@transcripe_router.websocket("/ws/{session_id}")
+async def websocket_endpoint(websocket: WebSocket, session_id: str, db: AsyncSession = Depends(get_db)):
+    await websocket.accept()
+    result = await get_session(db, session_id)
+    if not result:
+        result = await create_session(db, session_id)
+    if not result:
+        await websocket.send_json({"error": "Session not found nor created"})
+        await websocket.close()
+        return
+    chunk_number = 0
+    logger.info(f"WebSocket connection established for session {session_id}")
+    try:
+        while True:
+            data = await websocket.receive_bytes()
+            logger.info(f"Received audio chunk {chunk_number} ({len(data)} bytes)")
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as temp_file:
+                temp_file.write(data)
+                temp_path = temp_file.name
+            try:
+                controller = TranscriptionController(models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER)
+                text, language = await controller.transcribe_audio(temp_path)
+                if text:
+                    transcription = await create_transcription(db, session_id, chunk_number, text, language)
+                    await websocket.send_json({
+                        "chunk_number": chunk_number,
+                        "text": text,
+                        "language": language,
+                        "session_id": session_id
+                    })
+                    logger.info(f"Transcribed chunk {chunk_number} ({language}): {text[:50]}...")
+                else:
+                    logger.info(f"Chunk {chunk_number} ignored (Detected: {language})")
+                chunk_number += 1
+            finally:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected for session {session_id}")
+    except Exception as e:
+        logger.error(f"Error in WebSocket: {str(e)}")
+        await websocket.send_json({"error": str(e)})
+        await websocket.close()
+models={}
+async def load_models():
+    print("Loading Whisper models...")
+    if get_settings().INFERENCE_TYPE == "local":
+        if get_settings().LOCAL_INFERENCE_MODEL_SIZE == "small":
+            models["small_arabic"] = WhisperModel("Whisper-Small-MN-int8", device="cpu", compute_type="int8")
+            models["small_english"] = WhisperModel("small", device="cpu", compute_type="int8")
+        elif get_settings().LOCAL_INFERENCE_MODEL_SIZE == "base":
+            models["base_arabic"] = WhisperModel("Whisper-Base-MN-EG-int8", device="cpu", compute_type="int8")
+            models["base_english"] = WhisperModel("base", device="cpu", compute_type="int8")
+    print("Models loaded successfully ")
+    print(f"Loaded models: {list(models.keys())}")
+def register_startup_events(app: FastAPI):
+    @app.on_event("startup")
+    async def startup_event():
+        await load_models()
+def register_shutdown_events(app: FastAPI):
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        models.clear()
+        print("Models unloaded")

stores/providers/aaistt.py ADDED Viewed

	@@ -0,0 +1,31 @@

+import asyncio
+import assemblyai as aai
+from configs import get_settings
+settings = get_settings()
+aai.settings.api_key = settings.ASSEMBLYAI_API_KEY
+config = aai.TranscriptionConfig(
+    speech_models=["universal-2","universal-3-pro"],
+    language_detection=True,   # auto-detect language
+    speaker_labels=True,       # diarization
+)
+class AssemblyAISTT:
+    def __init__(self):
+        self.client = aai.Transcriber()
+    async def transcribe(self, audio_path: str):
+        # AssemblyAI's transcriber is synchronous, so we run it in a thread
+        loop = asyncio.get_event_loop()
+        def sync_transcribe():
+            transcript = self.client.transcribe(audio_path,config=config)
+            if transcript.status == aai.TranscriptStatus.error:
+                raise Exception(f"Transcription failed: {transcript.error}")
+            text = transcript.text
+            # Language detection is available in transcript.language_code
+            language = transcript.language_code if transcript.language_code else "unknown"
+            return text, language
+        return await loop.run_in_executor(None, sync_transcribe)

stores/providers/customstt.py ADDED Viewed

	@@ -0,0 +1,35 @@

+import os
+import aiohttp
+from configs import get_settings
+settings = get_settings()
+class CustomSTT:
+    def __init__(self):
+        # The base URL from the Colab notebook (set in your environment/config)
+        self.base_url = settings.CUSTOM_STT_URL.rstrip("/")
+        self.endpoint = f"{self.base_url}/transcribe"
+        # Optional API key if you added one to the endpoint
+        self.api_key = getattr(settings, "CUSTOM_STT_API_KEY", None)
+    async def transcribe(self, audio_path: str):
+        """Send audio file to custom STT server and return (text, language)."""
+        async with aiohttp.ClientSession() as session:
+            with open(audio_path, "rb") as f:
+                form_data = aiohttp.FormData()
+                form_data.add_field(
+                    "file",
+                    f,
+                    filename=os.path.basename(audio_path),
+                    content_type="audio/wav"
+                )
+                headers = {}
+                if self.api_key:
+                    headers["X-API-Key"] = self.api_key
+                async with session.post(self.endpoint, data=form_data, headers=headers) as resp:
+                    if resp.status != 200:
+                        error_text = await resp.text()
+                        raise Exception(f"Custom STT error {resp.status}: {error_text}")
+                    data = await resp.json()
+                    return data["text"], data["language"]

stores/providers/deepgramstt.py ADDED Viewed

	@@ -0,0 +1,33 @@

+import os
+import asyncio
+from deepgram import DeepgramClient
+from configs import get_settings
+settings = get_settings()
+class DeepgramSTT:
+    def __init__(self):
+        self.client = DeepgramClient(api_key=settings.DEEPGRAM_API_KEY)
+        self.model = settings.DEEPGRAM_MODEL
+    async def transcribe(self, audio_path: str):
+        loop = asyncio.get_event_loop()
+        def sync_transcribe():
+            with open(audio_path, "rb") as audio_file:
+                response = self.client.listen.v1.media.transcribe_file(
+                    request=audio_file.read(),
+                    model=self.model,
+                    smart_format=True,
+                    language=None,           # auto-detect
+                )
+            # Extract transcript
+            transcript = response.results.channels[0].alternatives[0].transcript
+            # Extract language from metadata (if available)
+            language = getattr(response.metadata, "language", "unknown")
+            return transcript, language
+        return await loop.run_in_executor(None, sync_transcribe)

stores/providers/groqstt.py ADDED Viewed

	@@ -0,0 +1,29 @@

+import os
+import asyncio
+from groq import Groq
+from configs import get_settings
+settings = get_settings()
+client = Groq(api_key=settings.GROQ_API_KEY)
+class GroqSTT:
+    def __init__(self):
+        self.client = client
+        self.model = settings.GROQ_MODEL
+    async def transcribe(self, audio_path: str) -> str:
+        loop = asyncio.get_event_loop()
+        def sync_transcribe():
+            with open(audio_path, "rb") as file:
+                transcription = self.client.audio.transcriptions.create(
+                    file=(os.path.basename(audio_path), file.read()),
+                    model=self.model,
+                    response_format="json",
+                )
+            return transcription.text, "unknown"
+        text, language = await loop.run_in_executor(None, sync_transcribe)
+        return text, language

stores/providers/mistralstt.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import os
+import asyncio
+from mistralai import Mistral
+from configs import get_settings
+settings = get_settings()
+client = Mistral(api_key=settings.MISTRAL_API_KEY)
+class MistralSTT:
+    def __init__(self):
+        self.client = client
+        self.model = settings.MISTRAL_MODEL
+    async def transcribe(self, audio_path: str) -> str:
+        loop = asyncio.get_event_loop()
+        def sync_transcribe():
+            with open(audio_path, "rb") as f:
+                response = self.client.audio.transcriptions.complete(
+                    model=self.model,
+                    file={"content": f, "file_name": os.path.basename(audio_path)}
+                )
+            return response.text, "unknown"
+        text, language = await loop.run_in_executor(None, sync_transcribe)
+        return text, language

stores/sttremotes.py ADDED Viewed

	@@ -0,0 +1,31 @@

+from typing import Dict, Type
+from .providers.mistralstt import MistralSTT
+from .providers.groqstt import GroqSTT
+from .providers.deepgramstt import DeepgramSTT
+from .providers.aaistt import AssemblyAISTT
+from .providers.customstt import CustomSTT
+class STTFactory:
+    _providers: Dict[str, Type] = {
+        "mistral": MistralSTT,
+        "groq": GroqSTT,
+        "deepgram": DeepgramSTT,
+        "assemblyai": AssemblyAISTT,
+        "custom": CustomSTT,
+    }
+    @classmethod
+    def get_provider(cls, provider_name: str):
+        provider_class = cls._providers.get(provider_name.lower())
+        if not provider_class:
+            raise ValueError(f"STT provider '{provider_name}' not found")
+        return provider_class()
+class STTRemoteManager:
+    def __init__(self, default_provider: str = "mistral"):
+        self.default_provider = default_provider
+    async def transcribe_remote(self, audio_path: str, provider_name: str = None) -> str:
+        provider_name = provider_name or self.default_provider
+        provider = STTFactory.get_provider(provider_name)
+        return await provider.transcribe(audio_path)