feat(openvino): реализован OpenVINO бэкенд транскрипции

- Зачем:
  - ускорение транскрипции на x86 CPU (Intel/AMD) в 2-4 раза через OpenVINO GenAI.
- Что:
  - создан backends/openvino.py: OpenVINOBackend с ensure_model_available, create_model, transcribe.
  - модели скачиваются из HuggingFace (OpenVINO/whisper-*-ov), формат OpenVINO IR.
  - аудио декодируется через faster_whisper.decode_audio (PyAV) → .tolist() → pipe.generate(return_timestamps=True).
  - контракт compute_type: явный --compute-type уважается; из дефолтов large-v3 получает fp16 автоматически.
  - openvino-genai добавлен в pyproject.toml с platform markers (x86_64/AMD64, не macOS).
  - compute_type_explicit прокинут через get_backend → load_model → CLI.
  - 16 тестов для OpenVINO бэкенда: resolve_repo, ensure, create, transcribe, validate.
- Проверка:
  - uv run pytest -v — 119 passed.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/local_transcriber/backends/__init__.py

@@ -8,10 +8,11 @@ if TYPE_CHECKING:
     from .base import Backend
 
 
-def get_backend(device: str) -> Backend:
+def get_backend(device: str, *, compute_type_explicit: bool = True) -> Backend:
     """Возвращает экземпляр бэкенда для указанного устройства.
 
     Импорты ленивые — бэкенд загружается только при запросе.
+    compute_type_explicit: False если compute_type пришёл из дефолтов (влияет на fallback).
     """
     if device == "openvino":
         try:
@@ -20,7 +21,7 @@ def get_backend(device: str) -> Backend:
             raise ValueError(
                 "OpenVINO бэкенд недоступен. Установите: pip install openvino-genai"
             ) from None
-        return OpenVINOBackend()
+        return OpenVINOBackend(compute_type_explicit=compute_type_explicit)
 
     # cuda, cpu и всё остальное → faster-whisper
     from .faster_whisper import FasterWhisperBackend

src/local_transcriber/backends/openvino.py

@@ -0,0 +1,179 @@
+"""Бэкенд транскрипции на основе OpenVINO GenAI."""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import snapshot_download
+from huggingface_hub.errors import LocalEntryNotFoundError
+
+from local_transcriber.types import Segment, TranscribeResult
+
+# (model_alias, compute_type) → HF repo
+MODEL_REPOS: dict[tuple[str, str], str] = {
+    ("tiny", "int8"): "OpenVINO/whisper-tiny-int8-ov",
+    ("base", "fp16"): "OpenVINO/whisper-base-fp16-ov",
+    ("small", "int8"): "OpenVINO/whisper-small-int8-ov",
+    ("medium", "int8"): "OpenVINO/whisper-medium-int8-ov",
+    ("large-v3", "int8"): "OpenVINO/whisper-large-v3-int8-ov",
+    ("large-v3", "fp16"): "OpenVINO/whisper-large-v3-fp16-ov",
+}
+
+# Fallback: если точная пара не найдена, пробуем альтернативный compute_type
+_COMPUTE_TYPE_FALLBACKS: dict[str, list[str]] = {
+    "float32": ["fp16", "int8"],
+    "float16": ["fp16", "int8"],
+    "fp16": ["fp16", "int8"],
+    "int8": ["int8", "fp16"],
+}
+
+# large-v3: при неявном compute_type предпочитаем fp16 (стабильнее по качеству)
+_IMPLICIT_COMPUTE_TYPE_OVERRIDES: dict[str, str] = {
+    "large-v3": "fp16",
+}
+
+MODEL_REQUIRED_FILES = [
+    "openvino_encoder_model.xml",
+    "openvino_decoder_model.xml",
+]
+
+
+class OpenVINOBackend:
+    """Бэкенд транскрипции через openvino-genai WhisperPipeline."""
+
+    def __init__(self, compute_type_explicit: bool = True):
+        """compute_type_explicit=False означает, что compute_type пришёл из дефолтов."""
+        self._compute_type_explicit = compute_type_explicit
+
+    def ensure_model_available(
+        self,
+        model_name: str,
+        compute_type: str,
+        on_status: Callable[[str], None] | None = None,
+    ) -> str:
+        """Скачивает/находит OpenVINO модель нужной квантизации."""
+        repo_id = self._resolve_repo(model_name, compute_type)
+
+        try:
+            _notify(on_status, f"Проверяю кэш модели {model_name} (OpenVINO)...")
+            cached_path = Path(snapshot_download(repo_id, local_files_only=True))
+            _validate_model_dir(cached_path)
+            return str(cached_path)
+        except LocalEntryNotFoundError:
+            pass
+        except ValueError:
+            _notify(on_status, f"Кэш модели {model_name} неполный, докачиваю...")
+
+        _notify(on_status, f"Скачиваю модель {model_name} (OpenVINO) из Hugging Face...")
+        downloaded_path = Path(snapshot_download(repo_id, local_files_only=False))
+        _validate_model_dir(downloaded_path)
+        return str(downloaded_path)
+
+    def create_model(
+        self,
+        model_path: str,
+        device: str,
+        compute_type: str,
+    ) -> Any:
+        """Создаёт WhisperPipeline."""
+        import openvino_genai as ov_genai
+
+        return ov_genai.WhisperPipeline(model_path, "CPU")
+
+    def transcribe(
+        self,
+        model: Any,
+        file_path: Path,
+        language: str | None,
+        on_segment: Callable[[Segment], None] | None = None,
+        on_status: Callable[[str], None] | None = None,
+    ) -> TranscribeResult:
+        """Транскрибирует файл через OpenVINO GenAI."""
+        from faster_whisper import decode_audio
+
+        _notify(on_status, "Загружаю аудио...")
+        raw_speech = decode_audio(str(file_path), sampling_rate=16000)
+        duration = len(raw_speech) / 16000.0
+
+        kwargs: dict[str, Any] = {"return_timestamps": True}
+        if language:
+            kwargs["language"] = f"<|{language}|>"
+
+        _notify(on_status, "Транскрибирую (OpenVINO)...")
+        result = model.generate(raw_speech.tolist(), **kwargs)
+
+        segments: list[Segment] = []
+        if hasattr(result, "chunks") and result.chunks:
+            for chunk in result.chunks:
+                seg = Segment(
+                    start=chunk.start_ts,
+                    end=chunk.end_ts,
+                    text=chunk.text,
+                )
+                if on_segment is not None:
+                    on_segment(seg)
+                segments.append(seg)
+                _notify(
+                    on_status,
+                    f"Транскрибирую (OpenVINO)... [{len(segments)} сегм.]",
+                )
+
+        detected_language = language or "auto"
+        language_probability = 1.0 if language else 0.0
+
+        return TranscribeResult(
+            segments=segments,
+            language=detected_language,
+            language_probability=language_probability,
+            duration=duration,
+            device_used="",  # оркестратор проставит
+        )
+
+    def _resolve_repo(self, model_name: str, compute_type: str) -> str:
+        """Находит HF repo для пары (model, compute_type) с fallback."""
+        # Для неявного compute_type: override для конкретных моделей
+        if not self._compute_type_explicit and model_name in _IMPLICIT_COMPUTE_TYPE_OVERRIDES:
+            compute_type = _IMPLICIT_COMPUTE_TYPE_OVERRIDES[model_name]
+
+        # Точное совпадение
+        repo = MODEL_REPOS.get((model_name, compute_type))
+        if repo:
+            return repo
+
+        # Fallback только для неявного compute_type
+        if not self._compute_type_explicit:
+            fallbacks = _COMPUTE_TYPE_FALLBACKS.get(compute_type, [])
+            for fallback_ct in fallbacks:
+                repo = MODEL_REPOS.get((model_name, fallback_ct))
+                if repo:
+                    return repo
+
+        # Явный --compute-type с несуществующей парой → ошибка
+        available = [ct for (m, ct) in MODEL_REPOS if m == model_name]
+        if available:
+            raise ValueError(
+                f"Модель '{model_name}' недоступна с compute_type='{compute_type}' для OpenVINO. "
+                f"Доступные варианты: {', '.join(sorted(set(available)))}"
+            )
+
+        all_models = sorted({m for m, _ in MODEL_REPOS})
+        raise ValueError(
+            f"Модель '{model_name}' не найдена для OpenVINO. "
+            f"Доступные модели: {', '.join(all_models)}"
+        )
+
+
+def _notify(on_status: Callable[[str], None] | None, message: str) -> None:
+    if on_status is not None:
+        on_status(message)
+
+
+def _validate_model_dir(model_dir: Path) -> None:
+    missing = [f for f in MODEL_REQUIRED_FILES if not (model_dir / f).exists()]
+    if missing:
+        raise ValueError(
+            f"Неполная OpenVINO модель в '{model_dir}': отсутствуют {', '.join(missing)}"
+        )

src/local_transcriber/cli.py

@@ -72,6 +72,8 @@ def main(
         resolved_device = detect_device(defaults["device"])
         defaults = apply_device_defaults(defaults, resolved_device, cli_values, config)
 
+        ct_explicit = compute_type is not None
+
         expanded = expand_globs(files)
         if not expanded:
             console.print("Файлы не найдены.", style="red bold")
@@ -83,9 +85,9 @@ def main(
             raise SystemExit(1)
 
         if is_batch:
-            _run_batch(expanded, defaults, verbose, force)
+            _run_batch(expanded, defaults, verbose, force, ct_explicit)
         else:
-            _run_single(expanded[0], defaults, output, verbose)
+            _run_single(expanded[0], defaults, output, verbose, ct_explicit)
     except KeyboardInterrupt:
         console.print("\nПрервано пользователем.", style="yellow")
         raise SystemExit(130)
@@ -122,6 +124,7 @@ def _run_single(
     defaults: dict[str, str],
     output: Path | None,
     verbose: bool,
+    compute_type_explicit: bool = False,
 ) -> None:
     """Пайплайн одного файла: валидация → модель → транскрипция → запись."""
     start = time.monotonic()
@@ -145,6 +148,7 @@ def _run_single(
     model_obj, actual_device, backend, model_path = load_model(
         defaults["model"], resolved_device, defaults["compute_type"],
         on_status=lambda msg: console.print(msg), strict_device=strict,
+        compute_type_explicit=compute_type_explicit,
     )
 
     with Status("Подготавливаю запуск...", console=console) as status:
@@ -204,6 +208,7 @@ def _run_batch(
     defaults: dict[str, str],
     verbose: bool,
     force: bool,
+    compute_type_explicit: bool = False,
 ) -> None:
     """Трёхфазный батч-пайплайн: prescan → загрузка модели → транскрипция."""
     # Phase 1: Prescan — fail-fast + skip до загрузки модели (экономим ~2-5 сек)
@@ -240,6 +245,7 @@ def _run_batch(
     model_obj, actual_device, backend, model_path = load_model(
         defaults["model"], resolved_device, defaults["compute_type"],
         on_status=lambda msg: console.print(msg), strict_device=strict,
+        compute_type_explicit=compute_type_explicit,
     )
 
     if actual_device != resolved_device:

src/local_transcriber/transcriber.py

@@ -21,12 +21,14 @@ def load_model(
     compute_type: str,
     on_status: Callable[[str], None] | None = None,
     strict_device: bool = False,
+    compute_type_explicit: bool = False,
 ) -> tuple[Any, str, Any, str]:
     """Загружает модель: ensure + create с fallback.
 
     Возвращает (model, actual_device, backend, model_path).
+    compute_type_explicit: True если пользователь явно указал --compute-type.
     """
-    backend = get_backend(device)
+    backend = get_backend(device, compute_type_explicit=compute_type_explicit)
     actual_device = device
 
     model_path = backend.ensure_model_available(model_name, compute_type, on_status)