Рабочий пайплайн: YouTube -> транскрипция -> выжимка -> Postgres

- новый api/: /pipeline/process (yt-dlp, субтитры или Vosk, LLM/экстрактивная
  суммаризация), /videos, /llm; старый код перенесён в api_legacy/
- web/: Flet UI (flet 0.28.3 + flet-web, порт 8550)
- Dockerfile.api: ffmpeg слоем из mwader/static-ffmpeg, pip с кэш-маунтом
- requirements/pyproject: убраны moviepy, imageio-ffmpeg, битый asyncio
- README с инструкцией запуска и загрузкой Vosk-модели

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

api_legacy/lib/audio_processing.py

@@ -0,0 +1,134 @@
+from pathlib import Path
+import os
+import sys
+import threading
+import logging
+import wave
+import json
+import subprocess
+import shutil
+
+try:
+    from vosk import Model, KaldiRecognizer
+except Exception:
+    Model = None
+    KaldiRecognizer = None
+
+
+class FFmpegConverter:
+    """Utility to convert audio files using ffmpeg."""
+
+    @staticmethod
+    def convert_mp3_to_wav(src: Path, dest: Path) -> None:
+        cmd = [
+            "ffmpeg",
+            "-y",
+            "-i",
+            str(src),
+            "-ac",
+            "1",
+            "-ar",
+            "16000",
+            "-vn",
+            "-f",
+            "wav",
+            str(dest),
+        ]
+        subprocess.run(cmd, check=True)
+
+
+class VoskModelManager:
+    """Loads a Vosk model and provides transcription methods.
+
+    Loading captures model stderr into Python logs to show progress.
+    """
+
+    def __init__(self, model_path: Path):
+        self.logger = logging.getLogger("vosk.model_manager")
+        if Model is None or KaldiRecognizer is None:
+            raise RuntimeError("vosk is not installed in runtime")
+        self.model = self._load_model_with_progress(model_path)
+
+    def _load_model_with_progress(self, path: Path):
+        logger = logging.getLogger("vosk.loader")
+        r_fd, w_fd = os.pipe()
+        saved_stderr_fd = os.dup(sys.stderr.fileno())
+        os.dup2(w_fd, sys.stderr.fileno())
+
+        def _reader(fd):
+            with os.fdopen(fd, "rb") as fh:
+                for raw in iter(fh.readline, b""):
+                    try:
+                        logger.info(raw.decode(errors="ignore").rstrip())
+                    except Exception:
+                        pass
+
+        reader_thread = threading.Thread(target=_reader, args=(r_fd,), daemon=True)
+        reader_thread.start()
+
+        try:
+            model = Model(str(path))
+        finally:
+            try:
+                os.dup2(saved_stderr_fd, sys.stderr.fileno())
+            except Exception:
+                pass
+            try:
+                os.close(saved_stderr_fd)
+            except Exception:
+                pass
+            reader_thread.join(timeout=2)
+
+        return model
+
+    def transcribe_wav(self, wav_path: Path) -> str:
+        if not wav_path.exists():
+            raise FileNotFoundError(wav_path)
+        try:
+            with wave.open(str(wav_path), "rb") as wf:
+                if wf.getnchannels() != 1:
+                    raise ValueError("Audio must be mono (1 channel)")
+                recognizer = KaldiRecognizer(self.model, wf.getframerate())
+                try:
+                    recognizer.SetWords(True)
+                except Exception:
+                    # older vosk bindings may not expose SetWords; ignore if absent
+                    pass
+                while True:
+                    data = wf.readframes(4000)
+                    if not data:
+                        break
+                    recognizer.AcceptWaveform(data)
+                result = json.loads(recognizer.FinalResult())
+                return result.get("text", "")
+        except wave.Error as e:
+            raise ValueError(f"Invalid WAV file: {e}")
+
+    def transcribe_wav_with_words(self, wav_path: Path):
+        """Transcribe WAV and return dict with 'text' and 'words' (word-level timestamps).
+
+        Returns: { 'text': str, 'words': [{'word': str, 'start': float, 'end': float}, ...] }
+        """
+        if not wav_path.exists():
+            raise FileNotFoundError(wav_path)
+        try:
+            with wave.open(str(wav_path), "rb") as wf:
+                if wf.getnchannels() != 1:
+                    raise ValueError("Audio must be mono (1 channel)")
+                recognizer = KaldiRecognizer(self.model, wf.getframerate())
+                try:
+                    recognizer.SetWords(True)
+                except Exception:
+                    pass
+                while True:
+                    data = wf.readframes(4000)
+                    if not data:
+                        break
+                    recognizer.AcceptWaveform(data)
+                res = json.loads(recognizer.FinalResult())
+                words = res.get("result", [])
+                # words are dictionaries with word, start, end
+                text = res.get("text", "")
+                return {"text": text, "words": words}
+        except wave.Error as e:
+            raise ValueError(f"Invalid WAV file: {e}")