ddadminandClaude Opus 4.6
aac6b0f3d6
- Зачем: - индикатор "00:32 / 16:02" был неочевиден — два одинаковых формата. - путь в "Транскрипт сохранён" отображался разным цветом из-за Rich bold-разметки. - Что: - формат прогресса: "Транскрибирую 16 мин аудио (OpenVINO)... прошло 00:32". - путь выводится в кавычках без bold-разметки, единым цветом. - Проверка: - uv run pytest -q — 124 passed. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
352 lines
13 KiB
Python
352 lines
13 KiB
Python
"""CLI-точка входа (typer). Single и batch режимы транскрипции."""
|
||
|
||
import sys
|
||
import time
|
||
from pathlib import Path
|
||
|
||
import typer
|
||
from rich.console import Console
|
||
from rich.status import Status
|
||
|
||
from .config import apply_device_defaults, load_config, resolve_defaults
|
||
from .formatter import format_transcript, write_transcript
|
||
from .transcriber import (
|
||
Segment,
|
||
_is_cuda_error,
|
||
_transcribe_file,
|
||
load_model,
|
||
)
|
||
from .utils import (
|
||
build_output_path,
|
||
detect_device,
|
||
expand_globs,
|
||
get_gpu_name,
|
||
has_existing_transcript,
|
||
validate_input_file,
|
||
)
|
||
|
||
app = typer.Typer()
|
||
console = Console(stderr=True)
|
||
|
||
|
||
def _format_device_info(device_used: str) -> str:
|
||
"""Формирует строку устройства для шапки транскрипта."""
|
||
if device_used == "cuda":
|
||
gpu_name = get_gpu_name()
|
||
return f"CUDA ({gpu_name or 'Unknown GPU'})"
|
||
if device_used == "openvino":
|
||
return "OpenVINO (CPU)"
|
||
return "CPU"
|
||
|
||
|
||
@app.command()
|
||
def main(
|
||
files: list[Path] = typer.Argument(..., help="Пути к аудио/видеофайлам"),
|
||
model: str | None = typer.Option(
|
||
None, "--model", "-m", show_default=False, help="Модель Whisper [по умолч.: medium]"
|
||
),
|
||
language: str | None = typer.Option(
|
||
None, "--language", "-l", show_default=False, help="Язык [по умолч.: ru]"
|
||
),
|
||
output: Path | None = typer.Option(None, "--output", "-o", help="Путь к выходному файлу"),
|
||
device: str | None = typer.Option(
|
||
None, "--device", "-d", show_default=False,
|
||
help="Устройство (auto|cpu|cuda|openvino) [по умолч.: auto]"
|
||
),
|
||
compute_type: str | None = typer.Option(
|
||
None, "--compute-type", show_default=False,
|
||
help="Тип вычислений [по умолч.: float16 (CUDA) / int8 (OpenVINO) / float32 (CPU)]"
|
||
),
|
||
verbose: bool = typer.Option(False, "--verbose", "-v", help="Подробный вывод"),
|
||
force: bool = typer.Option(False, "--force", "-f", help="Перезаписать существующие транскрипты"),
|
||
) -> None:
|
||
"""Транскрибирует аудио/видеофайлы в markdown с таймкодами.
|
||
|
||
Каскад приоритетов параметров: CLI-флаги > .transcriber.toml > device-aware дефолты.
|
||
"""
|
||
try:
|
||
config = load_config()
|
||
cli_values = {"model": model, "language": language, "device": device, "compute_type": compute_type}
|
||
defaults = resolve_defaults(cli_values, config)
|
||
|
||
resolved_device = detect_device(defaults["device"])
|
||
defaults = apply_device_defaults(defaults, resolved_device, cli_values, config)
|
||
|
||
ct_explicit = compute_type is not None or "compute_type" in config
|
||
|
||
expanded = expand_globs(files)
|
||
if not expanded:
|
||
console.print("Файлы не найдены.", style="red bold")
|
||
raise SystemExit(1)
|
||
|
||
is_batch = len(expanded) > 1
|
||
if is_batch and output is not None:
|
||
console.print("--output несовместим с несколькими файлами.", style="red bold")
|
||
raise SystemExit(1)
|
||
|
||
if is_batch:
|
||
_run_batch(expanded, defaults, verbose, force, ct_explicit)
|
||
else:
|
||
_run_single(expanded[0], defaults, output, verbose, ct_explicit)
|
||
except KeyboardInterrupt:
|
||
console.print("\nПрервано пользователем.", style="yellow")
|
||
raise SystemExit(130)
|
||
except SystemExit:
|
||
raise
|
||
except ValueError as exc:
|
||
console.print(f"Ошибка: {exc}", style="red bold")
|
||
raise SystemExit(1)
|
||
except (FileNotFoundError,) as exc:
|
||
console.print(f"Ошибка: {exc}", style="red bold")
|
||
raise SystemExit(1)
|
||
except Exception as exc:
|
||
if _is_cuda_error(exc) and sys.platform == "win32":
|
||
console.print(
|
||
"GPU на Windows требует CUDA toolkit (включает cuBLAS).\n"
|
||
"Установите одним из способов:\n"
|
||
" choco install cuda\n"
|
||
" winget install -e --id Nvidia.CUDA\n"
|
||
"После установки перезапустите терминал.",
|
||
style="yellow",
|
||
)
|
||
if verbose:
|
||
console.print_exception()
|
||
else:
|
||
console.print(f"Ошибка: {exc}", style="red bold")
|
||
console.print(
|
||
"Запустите с --verbose для полного traceback.", style="dim"
|
||
)
|
||
raise SystemExit(1)
|
||
|
||
|
||
def _run_single(
|
||
file: Path,
|
||
defaults: dict[str, str],
|
||
output: Path | None,
|
||
verbose: bool,
|
||
compute_type_explicit: bool = False,
|
||
) -> None:
|
||
"""Пайплайн одного файла: валидация → модель → транскрипция → запись."""
|
||
start = time.monotonic()
|
||
|
||
validated_file = validate_input_file(file)
|
||
requested_device = defaults["device"]
|
||
resolved_device = detect_device(requested_device)
|
||
strict = requested_device != "auto"
|
||
output_path = build_output_path(validated_file, output)
|
||
|
||
console.print(f"Файл: [bold]{validated_file.name}[/bold]")
|
||
|
||
def on_segment(seg: Segment) -> None:
|
||
console.print(f" [{seg.start:.2f}s] {seg.text.strip()}")
|
||
|
||
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,
|
||
)
|
||
actual_ct = getattr(backend, "actual_compute_type", defaults["compute_type"]) or defaults["compute_type"]
|
||
console.print(
|
||
f"Модель: [bold]{defaults['model']}[/bold] "
|
||
f"Устройство: [bold]{actual_device}[/bold] "
|
||
f"Compute: [bold]{actual_ct}[/bold]"
|
||
)
|
||
|
||
with Status("Подготавливаю запуск...", console=console) as status:
|
||
tfr = _transcribe_file(
|
||
model=model_obj,
|
||
actual_device=actual_device,
|
||
backend=backend,
|
||
model_path=model_path,
|
||
file_path=validated_file,
|
||
model_name=defaults["model"],
|
||
compute_type=defaults["compute_type"],
|
||
language=defaults["language"] if defaults["language"] != "auto" else None,
|
||
on_segment=on_segment if verbose else None,
|
||
on_status=status.update,
|
||
strict_device=strict,
|
||
)
|
||
|
||
result = tfr.result
|
||
|
||
if tfr.actual_device != resolved_device:
|
||
if requested_device == "auto":
|
||
console.print(
|
||
f"Определено устройство {resolved_device}, "
|
||
f"но использовано {tfr.actual_device} (fallback)",
|
||
style="yellow",
|
||
)
|
||
else:
|
||
console.print(
|
||
f"Запрошено {requested_device}, использовано {tfr.actual_device}",
|
||
style="yellow",
|
||
)
|
||
|
||
if len(result.segments) == 0:
|
||
console.print(
|
||
f"Речь не обнаружена в файле {validated_file.name}", style="yellow"
|
||
)
|
||
|
||
device_info = _format_device_info(result.device_used)
|
||
language_mode = "detected" if defaults["language"] == "auto" else "forced"
|
||
|
||
content = format_transcript(
|
||
result=result,
|
||
source_filename=validated_file.name,
|
||
model_name=defaults["model"],
|
||
device_info=device_info,
|
||
language_mode=language_mode,
|
||
)
|
||
write_transcript(content, output_path)
|
||
|
||
elapsed = time.monotonic() - start
|
||
console.print(f"Транскрипт сохранён: \"{output_path}\"", style="green")
|
||
console.print(f" Сегментов: {len(result.segments)} Время: {elapsed:.1f}с")
|
||
|
||
|
||
def _run_batch(
|
||
files: list[Path],
|
||
defaults: dict[str, str],
|
||
verbose: bool,
|
||
force: bool,
|
||
compute_type_explicit: bool = False,
|
||
) -> None:
|
||
"""Трёхфазный батч-пайплайн: prescan → загрузка модели → транскрипция."""
|
||
# Phase 1: Prescan — fail-fast + skip до загрузки модели (экономим ~2-5 сек)
|
||
to_process: list[Path] = []
|
||
skipped = 0
|
||
invalid = 0
|
||
for file in files:
|
||
try:
|
||
validated = validate_input_file(file)
|
||
except (FileNotFoundError, ValueError) as exc:
|
||
console.print(f" Ошибка: {file.name}: {exc}", style="red")
|
||
invalid += 1
|
||
continue
|
||
if not force and has_existing_transcript(validated):
|
||
console.print(
|
||
f" Пропуск: {file.name} (транскрипт существует)", style="dim"
|
||
)
|
||
skipped += 1
|
||
continue
|
||
to_process.append(validated)
|
||
|
||
if not to_process:
|
||
console.print(
|
||
f"\nИтого: 0 обработано, {skipped} пропущено, {invalid} ошибок"
|
||
)
|
||
if invalid > 0:
|
||
raise SystemExit(1)
|
||
return
|
||
|
||
# Phase 2: Load model (ensure + create в одном вызове)
|
||
requested_device = defaults["device"]
|
||
resolved_device = detect_device(requested_device)
|
||
strict = requested_device != "auto"
|
||
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:
|
||
if requested_device == "auto":
|
||
console.print(
|
||
f"Определено устройство {resolved_device}, "
|
||
f"но используется {actual_device} (fallback)",
|
||
style="yellow",
|
||
)
|
||
else:
|
||
console.print(
|
||
f"Запрошено {requested_device}, используется {actual_device}",
|
||
style="yellow",
|
||
)
|
||
|
||
# Phase 3: Transcribe
|
||
processed = 0
|
||
failed = 0
|
||
language_mode = "detected" if defaults["language"] == "auto" else "forced"
|
||
|
||
batch_start = time.monotonic()
|
||
|
||
for i, file in enumerate(to_process, 1):
|
||
try:
|
||
prefix = f"[{i}/{len(to_process)}] {file.name}"
|
||
console.print(f"{prefix}", style="bold")
|
||
file_start = time.monotonic()
|
||
|
||
def on_segment(seg: Segment) -> None:
|
||
console.print(f" [{seg.start:.2f}s] {seg.text.strip()}")
|
||
|
||
with Status(f"{prefix}...", console=console) as status:
|
||
tfr = _transcribe_file(
|
||
model=model_obj,
|
||
actual_device=actual_device,
|
||
backend=backend,
|
||
model_path=model_path,
|
||
file_path=file,
|
||
model_name=defaults["model"],
|
||
compute_type=defaults["compute_type"],
|
||
language=defaults["language"] if defaults["language"] != "auto" else None,
|
||
on_segment=on_segment if verbose else None,
|
||
on_status=status.update if not verbose else lambda msg: console.print(msg),
|
||
strict_device=strict,
|
||
)
|
||
|
||
if tfr.actual_device != actual_device:
|
||
console.print(
|
||
f" {file.name}: fallback на {tfr.actual_device} при транскрипции",
|
||
style="yellow",
|
||
)
|
||
# Обновляем после возможного mid-stream fallback
|
||
model_obj = tfr.model
|
||
actual_device = tfr.actual_device
|
||
backend = tfr.backend
|
||
model_path = tfr.model_path
|
||
|
||
result = tfr.result
|
||
|
||
if len(result.segments) == 0:
|
||
console.print(
|
||
f" Речь не обнаружена: {file.name}", style="yellow"
|
||
)
|
||
|
||
device_info = _format_device_info(result.device_used)
|
||
|
||
content = format_transcript(
|
||
result=result,
|
||
source_filename=file.name,
|
||
model_name=defaults["model"],
|
||
device_info=device_info,
|
||
language_mode=language_mode,
|
||
)
|
||
write_transcript(content, build_output_path(file))
|
||
file_elapsed = time.monotonic() - file_start
|
||
console.print(
|
||
f" Готово: {file.name} "
|
||
f"Сегментов: {len(result.segments)} Время: {file_elapsed:.1f}с",
|
||
style="green",
|
||
)
|
||
processed += 1
|
||
except KeyboardInterrupt:
|
||
raise
|
||
except Exception as exc:
|
||
if verbose:
|
||
console.print_exception()
|
||
else:
|
||
console.print(f" Ошибка: {file.name}: {exc}", style="red")
|
||
failed += 1
|
||
|
||
total_failed = invalid + failed
|
||
batch_elapsed = time.monotonic() - batch_start
|
||
console.print(
|
||
f"\nИтого: {processed} обработано, {skipped} пропущено, {total_failed} ошибок"
|
||
f" Время: {batch_elapsed:.1f}с"
|
||
)
|
||
if total_failed > 0:
|
||
raise SystemExit(1)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
app()
|