7 Commits

Author SHA1 Message Date
EJClaw
b672c6ea4e fix: 로그 복사·저장이 화면 줄 수 제한(5000줄)에 걸려 앞부분을 잃던 것
Some checks failed
Windows / verify (push) Has been cancelled
화면은 최근 5000줄만 들고 있는데 복사·저장도 그 버퍼를 썼다. 오래 켜 두면
원인 찾기에 가장 필요한 시작 부분(GPU 준비·모델 로드)이 내보낸 로그에서
빠졌다. 내보내기는 이번 실행이 livesub.log 에 쓴 부분을 파일에서 다시 읽고,
저장 위치를 고르기 전의 줄을 앞에 붙인다. 파일을 못 쓰는 환경에서만 화면
버퍼로 돌아간다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 09:46:03 +09:00
EJClaw
42a38eb938 fix: 아무 말도 없는데 "Okay." 자막이 계속 뜨던 것 · 전체 로그 탭 추가
Some checks failed
Windows / verify (push) Has been cancelled
Silero 가 버린 구간을 VAD 없이 다시 받을 때 직전 문장을 prompt 로 넘겼다.
말소리가 없으면 Whisper 는 prompt 를 그대로 따라 적어서, 한 번 "Okay." 가
나오면 그 뒤 잡음마다 "Okay." 가 나왔다 (turbo, 잡음 11종 모두). 다시 받을
때는 prompt 를 넘기지 않고, prompt 없이도 잡음에서 나오는 상투 환각
("Obrigado." "you" "Thank you." 등)은 버린다. 수정 후 같은 잡음 22건 중
자막이 나온 것 0건.

로그 탭: 실행 중 로그 전체를 메모리에 모아 보여주고 복사·파일 저장을
지원한다. 확정 자막마다 원문·번역·확률을, VAD 없이 다시 받은 구간은 채택/
버림 결과를 INFO 로 남겨 엉뚱한 자막의 원인을 로그로 볼 수 있게 했다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 09:36:27 +09:00
EJClaw
c2e600fa3d fix: GPU 로 모델을 못 올려도 CPU 로 시작 · cuBLAS 받는 중 정지하면 캡처를 켜지 않게
Some checks failed
Windows / verify (push) Has been cancelled
- preload_on_start(기본값)에서 모델 로드가 GPU 오류를 내면 ERROR 로 끝나던 것을,
  CPU 로 바꿔 다시 올리게 했다.
- cuBLAS 를 받는 중에 정지하면 받기는 계속되고, 끝난 뒤 캡처가 켜져 상태가 다시
  RUNNING 이 되던 것을 고쳤다. 시작 작업마다 전용 정지 이벤트를 넘기고, 받기는
  그 이벤트를 보고 멈추며, 시작 작업은 정지된 뒤에는 캡처·상태를 건드리지 않는다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 15:11:19 +09:00
EJClaw
176e06c4bd test: 엔진 테스트가 Windows 에서 cuBLAS 를 실제로 받지 않게
Some checks failed
Windows / verify (push) Has been cancelled
기본 device=cuda 라 Windows 에서 엔진을 띄우면 시작 때 541MB 를 받느라
레벨 게이지 테스트(3초 제한)가 실패했다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 15:00:45 +09:00
EJClaw
bd24063c15 fix: exe 에서 GPU 로 받아 적을 때마다 실패해 자막이 안 나오던 것 (cuBLAS 누락)
Some checks failed
Windows / verify (push) Has been cancelled
CTranslate2 Windows 패키지는 GPU 계산 때 cublas64_12.dll 을 이름으로 불러오는데
포터블 exe 에는 이 파일(과 cublasLt64_12.dll)이 없다. 리눅스 GPU 점검은 torch 가
깔아 둔 cuBLAS 를 써서 통과했고, torch 를 뺀 exe 에서는 모델은 GPU 에 올라가지만
첫 문장부터 매번 실패했다. 실패는 로그에만 남아 화면은 '듣는 중' 그대로였다.

- 처음 GPU 를 쓸 때 NVIDIA 공식 nvidia-cublas-cu12 12.8.4.1(Blackwell 지원)을
  PyPI 에서 한 번 받아 모델 폴더에 두고 전체 경로로 미리 불러 둔다.
  크기·sha256 을 확인하고 DLL 두 개만 꺼낸다. 시스템에 이미 있으면 받지 않는다.
- 받기에 실패하거나 GPU 쪽 오류(cuda/cublas/cudnn)로 문장 처리가 실패하면 이번
  실행만 CPU 로 바꿔 같은 구간을 다시 처리한다. 설정 파일 값은 바꾸지 않는다.
- 문장 처리 실패와 CPU 전환 사유를 홈 화면 상태 줄에 띄운다.
- windows_smoke 에 cuBLAS 받기·불러오기 점검을 넣었다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 14:49:45 +09:00
EJClaw
1f59ed0679 fix: exe 에서 자막이 하나도 안 나오던 것 (Silero VAD 모델 누락)
Some checks failed
Windows / verify (push) Has been cancelled
포터블 exe 에 faster_whisper/assets/silero_vad_v6.onnx 가 빠져 있었다.
확정 문장 인식은 vad_filter=True 라서 매번 NoSuchFile 로 실패했고,
엔진이 경고 로그만 남기고 넘어가 어떤 목소리도 자막이 되지 않았다.
소스 점검(--pipeline)은 파일이 있는 venv 에서 돌아 통과했다.

- livesub.spec: collect_data_files("faster_whisper") 로 assets 를 넣는다.
- windows_smoke --exe: exe 안에 VAD 모델·용어집이 들어 있는지 확인한다.
  test7 exe 에 돌리면 silero_vad_v6.onnx 가 빠졌다고 실패한다.

함께, 효과가 걸린 게임 목소리를 Silero 가 통째로 버리던 것도 고친다.
사용자 녹음의 "Get up! Over here!" 는 Silero 확률이 0.14 라 사라졌다.
Silero 가 구간 전체를 버렸을 때만 VAD 없이 한 번 더 받고, 잡음 환각은
창 끝까지 이어진 구간(Thank you. 29.98s), 낮은 log 확률(< -1.0),
높은 압축률로 거른다. 실제 모델(turbo·small)로 사용자 녹음 대사 3개를
모두 받고 잡음 구간 5곳은 모두 빈 결과임을 확인했다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 17:29:00 +09:00
EJClaw
d9b23dd20b feat: 홈 화면 입력 소리 게이지가 번역 중 실제로 움직이게
Some checks failed
Windows / verify (push) Has been cancelled
게이지 위젯은 있었지만 엔진 상태 이벤트(시작·정지 때만 나감)로만 값을
받아서 번역 중에는 바닥에 멈춰 있었다. 소리가 들어오는지 확인할 방법이
없었다.

- 엔진이 최근 입력 RMS를 level 로 내주고, 메인 창이 번역 중에만 약 30Hz로 읽어 그린다
- 프레임이 끊기면(프로그램이 소리를 안 냄) 레벨을 0으로 내린다
- 게이지를 dB 눈금(-60~0 dBFS)으로 그린다. 평범한 대사(-30 dBFS)가 절반을 채운다
- 빠르게 오르고 천천히 내려가며, 최근 최고점을 세로선으로 잠깐 남긴다
- '입력 소리' 라벨과 '소리 받는 중 / 소리 없음' 문구를 옆에 붙였다

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:44:33 +09:00
21 changed files with 1369 additions and 62 deletions

View File

@@ -27,7 +27,7 @@
from pathlib import Path
from PyInstaller.utils.hooks import collect_dynamic_libs
from PyInstaller.utils.hooks import collect_data_files, collect_dynamic_libs
BLOCK_CIPHER = None
ROOT = Path(SPECPATH).parent # noqa: F821 - PyInstaller 가 주입
@@ -39,6 +39,11 @@ capture_exe = SRC / "livesub" / "resources" / "bin" / "livesub_capture.exe"
if capture_exe.is_file():
datas.append((str(capture_exe), "livesub/resources/bin"))
# faster-whisper 는 문장을 확정할 때 Silero VAD 모델(assets/silero_vad_v6.onnx)을
# 패키지 폴더에서 읽는다. .py 가 아닌 파일이라 PyInstaller 가 자동으로 넣지 않고,
# 빠지면 확정 문장 인식이 매번 실패해 자막이 하나도 안 나온다 (v0.3.0-test7 까지).
datas += collect_data_files("faster_whisper")
# CTranslate2 는 CUDA/cuDNN DLL 을 곁에 두고 로드한다. 자동 수집에서 빠지기 쉽다.
binaries = collect_dynamic_libs("ctranslate2")

View File

@@ -130,6 +130,23 @@ def run_source_checks() -> None:
raise RuntimeError(gpu.reason)
return f"{gpu.name} · {gpu.total_vram_mb / 1024:.1f}GB"
# CTranslate2 는 GPU 계산 때 cublas64_12.dll 을 이름으로 불러오는데, 포터블
# 빌드에는 이 파일이 없다 (v0.3.0-test8 까지 GPU 에서 자막이 안 나온 원인).
# 앱이 처음 GPU 를 쓸 때 받아 두는 경로가 실제로 받고 불러오는지 본다.
# GPU 가 없어도 DLL 은 올라간다. 한 번 받으면 다음부터는 캐시를 쓴다.
@check("GPU 계산 파일(cuBLAS) 받기·불러오기")
def _cublas():
import ctypes
from livesub.models import cuda_runtime
if not cuda_runtime.ensure(device="cuda"):
raise RuntimeError("Windows 인데 준비를 건너뛰었습니다")
ctypes.WinDLL("cublas64_12.dll") # CTranslate2 처럼 이름만으로 찾아지는지
import ctranslate2 # noqa: F401 - 미리 올린 DLL 과 같이 올라가는지
return str(cuda_runtime.runtime_dir())
@check("사용 가능한 모델 티어")
def _tiers():
from livesub.models.manager import has_torch, tier_availability
@@ -526,6 +543,21 @@ def _scratch_appdata():
shutil.rmtree(tmp, ignore_errors=True)
#: exe 안에 반드시 있어야 하는 .py 아닌 파일. 빠져도 창은 잘 뜨고 소스 점검도
#: 통과하므로, 실제로 말소리가 들어올 때가 돼서야 터진다.
EXE_REQUIRED_FILES = (
"faster_whisper/assets/silero_vad_v6.onnx", # 확정 문장 인식의 VAD
"livesub/resources/glossaries/fps-common.json",
)
def missing_bundle_files(exe: Path) -> list[str]:
from PyInstaller.archive.readers import CArchiveReader
names = {name.replace("\\", "/") for name in CArchiveReader(str(exe)).toc}
return [f for f in EXE_REQUIRED_FILES if f not in names]
def run_exe_check(exe: Path) -> None:
print(f"\n=== 빌드된 exe 점검: {exe} ===")
@@ -538,6 +570,13 @@ def run_exe_check(exe: Path) -> None:
raise RuntimeError(f"{mb:.0f}MB — 너무 큼. torch 가 섞여 들어갔는지 확인")
return f"{mb:.1f} MB"
@check("exe 에 실행 중 읽는 파일이 들어 있는지")
def _bundled_files():
missing = missing_bundle_files(exe)
if missing:
raise RuntimeError(f"빠짐: {', '.join(missing)}")
return f"{len(EXE_REQUIRED_FILES)}개 확인"
@check("exe 첫 실행 — 저장 위치 화면")
def _first_run():
# APPDATA 를 빈 폴더로 돌려 "처음 켜는 사람" 을 그대로 재현한다.

View File

@@ -9,6 +9,7 @@ from pathlib import Path
from .config import AppConfig
from .constants import APP_NAME, ORG_NAME, user_data_dir
from .log_buffer import BUFFER, BufferHandler
def setup_logging(verbose: bool = False, to_file: bool = True) -> None:
@@ -18,12 +19,19 @@ def setup_logging(verbose: bool = False, to_file: bool = True) -> None:
핸들러를 열면 사용자가 고르지도 않은 기본 폴더가 만들어지고 로그가
거기에 남는다.
"""
handlers: list[logging.Handler] = [logging.StreamHandler(sys.stderr)]
# 버퍼는 저장 위치와 상관없이 처음부터 붙인다. 저장 위치를 고르기 전의
# 로그도 '로그' 화면에서 보여야 한다. 다시 불려도 같은 버퍼에 이어 쌓인다.
handlers: list[logging.Handler] = [
logging.StreamHandler(sys.stderr),
BufferHandler(BUFFER),
]
if to_file:
path = user_data_dir() / "livesub.log"
with contextlib.suppress(OSError):
handlers.append(
logging.FileHandler(user_data_dir() / "livesub.log", encoding="utf-8")
)
# 이어 쓰는 파일이라 이전 실행 기록이 앞에 있다. 이번 실행분만 내보낸다.
offset = path.stat().st_size if path.exists() else 0
handlers.append(logging.FileHandler(path, encoding="utf-8"))
BUFFER.attach_file(path, offset)
logging.basicConfig(
level=logging.DEBUG if verbose else logging.INFO,
format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",

View File

@@ -9,6 +9,7 @@ from __future__ import annotations
import logging
import queue
import re
import threading
import time
from collections.abc import Callable
@@ -25,7 +26,8 @@ from ..audio import (
)
from ..config import AppConfig
from ..constants import LANGUAGE_CODES, user_data_dir
from ..models import Glossary, ModelManager
from ..models import Glossary, ModelManager, cuda_runtime
from ..models.cuda_runtime import DownloadCancelled
from ..models.manager import apply_vram_limit
from ..models.packs import build_glossary
from ..models.speech_level import (
@@ -38,6 +40,10 @@ from .events import EngineState, EngineStatus, TranslationLine
log = logging.getLogger(__name__)
#: GPU 쪽 문제로 보이는 예외 문구. 이런 실패는 CPU 로 바꾸면 자막이 나온다.
_GPU_ERROR = re.compile(r"cuda|cublas|cudnn|gpu", re.IGNORECASE)
_FAILED_PREFIX = "듣는 중 · 문장 처리 실패: "
StatusCallback = Callable[[EngineStatus], None]
LineCallback = Callable[[TranslationLine], None]
@@ -67,12 +73,23 @@ class TranslationEngine:
#: 마지막으로 실제 발화를 처리한 시각. 유휴 언로드 판단에 쓴다.
self._last_activity = time.monotonic()
self._models_unloaded = False
#: GPU 를 못 써서 CPU 로 돌고 있으면 그 사유. 홈 화면 상태에 보인다.
self._cpu_notice = ""
# --- 수명주기 -------------------------------------------------------
@property
def status(self) -> EngineStatus:
return self._status
@property
def level(self) -> float:
"""가장 최근 입력 오디오의 RMS(0~1). UI가 게이지용으로 주기적으로 읽는다.
상태 이벤트는 시작·정지 같은 때만 나가므로 게이지를 거기에 실으면
번역 중에 전혀 움직이지 않는다. 그래서 따로 읽어 가게 한다.
"""
return self._level
@property
def running(self) -> bool:
return self._status.state in (EngineState.RUNNING, EngineState.LOADING)
@@ -80,10 +97,15 @@ class TranslationEngine:
def start(self) -> None:
if self.running:
return
self._stop.clear()
# clear() 가 아니라 새로 만든다. 정지된 이전 시작 작업(예: cuBLAS 받는 중)이
# 아직 끝나지 않았을 수 있는데, 같은 이벤트를 다시 끄면 그 작업이 정지된
# 줄 모르고 캡처를 켜 버린다.
self._stop = threading.Event()
self._emit_status(EngineState.LOADING, "모델을 준비하고 있습니다…", 0.0)
thread = threading.Thread(target=self._bootstrap, name="engine-boot", daemon=True)
thread = threading.Thread(
target=self._bootstrap, args=(self._stop,), name="engine-boot", daemon=True
)
thread.start()
self._threads = [thread]
@@ -100,6 +122,7 @@ class TranslationEngine:
t.join(timeout=3)
self._threads = []
self._drain_segments()
self._level = 0.0
self._emit_status(EngineState.IDLE, "대기 중")
def shutdown(self) -> None:
@@ -134,20 +157,40 @@ class TranslationEngine:
return True
# --- 내부 스레드 ----------------------------------------------------
def _bootstrap(self) -> None:
def _bootstrap(self, stop: threading.Event) -> None:
"""모델·캡처를 준비한다. `stop` 은 이 시작 작업 전용 정지 신호다.
준비 도중(cuBLAS 받기, 모델 올리기)에 정지를 누를 수 있다. 그때는
캡처를 켜지도 상태를 바꾸지도 않고 조용히 끝낸다.
"""
def report(msg: str, pct: float) -> None:
if not stop.is_set():
self._emit_status(EngineState.LOADING, msg, pct)
self._cpu_notice = ""
try:
# 설정이 바뀐 채로 재시작됐을 수 있으므로 매 시작마다 맞춘다.
self.sync_performance()
self.models.use_device(self.config.models.device)
self._prepare_gpu(report, stop)
if stop.is_set():
return
perf = self.config.performance
if perf.game_mode and self.config.models.device == "cuda":
if perf.game_mode and self.models.device == "cuda":
# 모델을 올리기 *전에* 걸어야 상한이 실제로 먹는다.
apply_vram_limit(perf.vram_limit_ratio, self.config.models.device_index)
if self.config.models.preload_on_start:
self.models.preload(
lambda msg, pct: self._emit_status(EngineState.LOADING, msg, pct)
)
self._capture = create_capture(self.config.audio)
self._capture.start()
self._preload(report)
if stop.is_set():
return
capture = create_capture(self.config.audio)
capture.start()
self._capture = capture
if stop.is_set():
# stop() 이 캡처를 확인한 뒤에 여기 왔을 수 있다. 직접 닫는다.
capture.stop()
self._capture = None
return
workers = [
threading.Thread(target=self._segment_loop, name="engine-segment", daemon=True),
@@ -157,11 +200,41 @@ class TranslationEngine:
w.start()
self._threads.extend(workers)
kind = "프로그램별 캡처" if self._capture.per_process else "출력 장치 전체"
self._emit_status(EngineState.RUNNING, f"듣는 중 · {kind}", 1.0)
kind = "프로그램별 캡처" if capture.per_process else "출력 장치 전체"
message = self._cpu_notice or f"듣는 중 · {kind}"
self._emit_status(EngineState.RUNNING, message, 1.0)
except (CaptureError, OSError, RuntimeError, ImportError) as exc:
log.exception("엔진 시작 실패")
self._emit_status(EngineState.ERROR, str(exc))
if not stop.is_set():
self._emit_status(EngineState.ERROR, str(exc))
def _preload(self, report) -> None:
"""모델을 미리 올린다. GPU 로 안 올라가면 CPU 로 바꿔 다시 올린다."""
try:
self.models.preload(report)
except Exception as exc:
if self.models.device != "cuda" or not _GPU_ERROR.search(str(exc)):
raise
log.warning("GPU 로 모델을 올리지 못했습니다: %s", exc, exc_info=True)
self._fall_back_to_cpu(f"GPU 오류: {_short(exc)}")
self.models.preload(report)
def _prepare_gpu(self, report, stop: threading.Event) -> None:
"""GPU 계산에 필요한 파일을 준비한다. 안 되면 CPU 로 돌린다."""
if self.models.device != "cuda":
return
try:
cuda_runtime.ensure(report, cancel=stop)
except DownloadCancelled:
log.info("cuBLAS 받기를 멈췄습니다 (번역 정지)")
except Exception as exc: # noqa: BLE001 - 받기 실패여도 자막은 나와야 한다
log.warning("GPU 계산 파일을 준비하지 못했습니다: %s", exc, exc_info=True)
self._fall_back_to_cpu(f"GPU 계산 파일을 받지 못했습니다 ({_short(exc)})")
def _fall_back_to_cpu(self, reason: str) -> None:
self.models.use_device("cpu")
self._cpu_notice = f"CPU로 받아 적는 중 · {reason}"
log.warning("CPU 로 전환합니다: %s", reason)
def _segment_loop(self) -> None:
cfg = self.config.audio
@@ -183,6 +256,9 @@ class TranslationEngine:
break
chunk = capture.read(timeout=0.3)
if chunk is None:
# 프로그램이 소리를 안 내면 프레임 자체가 안 올 수 있다.
# 마지막 값을 들고 있으면 조용한데도 게이지가 떠 있게 된다.
self._level = 0.0
if capture.error is not None:
self._emit_status(EngineState.ERROR, str(capture.error))
return
@@ -227,21 +303,40 @@ class TranslationEngine:
if not segment.is_final and not self._segments.empty():
continue
self._process_safely(segment, mcfg)
# 게임에 GPU를 잠깐 돌려준다. 연속 발화 때 우리가 GPU를 독점하면
# 프레임이 눈에 띄게 끊긴다.
if perf.game_mode and perf.yield_ms > 0:
self._stop.wait(perf.yield_ms / 1000)
def _process_safely(self, segment: Segment, mcfg) -> None:
"""한 구간을 처리한다. 실패해도 엔진은 계속 돌고, 사용자에게 보인다.
예전에는 실패를 로그에만 남겨서, 매 문장이 실패해도 화면은 '듣는 중'
그대로였다. 사용자는 게이지만 움직이고 자막이 안 나오는 이유를 알 수 없었다.
"""
for attempt in range(2):
# 모델 참조를 캐시하지 않는다. 유휴 언로드 뒤에는 새로 올려야 하고,
# 캐시된 참조를 쓰면 이미 내려간 모델을 붙잡고 있게 된다.
try:
self._process(
segment, self.models.recognizer(), self.models.translator(), mcfg
)
self._last_activity = time.monotonic()
self._models_unloaded = False
except Exception as exc: # noqa: BLE001 - 한 문장 실패로 엔진이 죽으면 안 된다
log.warning("구간 처리 실패: %s", exc, exc_info=log.isEnabledFor(logging.DEBUG))
# 게임에 GPU를 잠깐 돌려준다. 연속 발화 때 우리가 GPU를 독점하면
# 프레임이 눈에 띄게 끊긴다.
if perf.game_mode and perf.yield_ms > 0:
self._stop.wait(perf.yield_ms / 1000)
log.warning("구간 처리 실패: %s", exc, exc_info=True)
if attempt == 0 and self.models.device == "cuda" and _GPU_ERROR.search(str(exc)):
# GPU 로는 안 되는 환경이다. 같은 구간을 CPU 로 다시 받아 적는다.
self._fall_back_to_cpu(f"GPU 오류: {_short(exc)}")
self._emit_status(EngineState.RUNNING, self._cpu_notice)
continue
self._emit_status(EngineState.RUNNING, f"{_FAILED_PREFIX}{_short(exc)}")
return
self._last_activity = time.monotonic()
self._models_unloaded = False
if self._status.message.startswith(_FAILED_PREFIX):
self._emit_status(EngineState.RUNNING, self._cpu_notice or "듣는 중")
return
def _maybe_unload_idle(self) -> None:
"""한동안 말소리가 없으면 모델을 내려 VRAM을 통째로 돌려준다.
@@ -304,6 +399,12 @@ class TranslationEngine:
translated = fix_particles(translated)
mt_ms = int((time.perf_counter() - t1) * 1000)
self._last_final_text = transcript.text
# '로그' 화면으로 받아 보는 진단용. 엉뚱한 자막이 뜨면 이 줄로 원인을 본다.
log.info(
"자막 %.1f초 %s %r → %r (인식 %dms · 번역 %dms · 확률 %.2f)",
transcript.duration_s, detected, transcript.text, translated,
asr_ms, mt_ms, transcript.avg_logprob,
)
line = TranslationLine(
source_text=transcript.text,
@@ -350,3 +451,9 @@ class TranslationEngine:
)
if self._on_status:
self._on_status(self._status)
def _short(exc: Exception, limit: int = 120) -> str:
"""상태 줄에 넣을 만큼 짧은 오류 문구."""
text = " ".join(str(exc).split()) or type(exc).__name__
return text if len(text) <= limit else text[: limit - 1] + "…"

106
src/livesub/log_buffer.py Normal file
View File

@@ -0,0 +1,106 @@
"""실행 중 로그를 모아 두는 곳. '로그' 화면이 여기서 읽는다.
`livesub.log` 파일만으로는 사용자가 찾아서 보내기 어렵다. 저장 위치를 직접
열어야 하고, 이전 실행 기록까지 섞여 있다. 그래서 화면에서 바로 복사·저장하게 한다.
화면에 보이는 줄(`lines`)은 메모리를 아끼려고 최근 것만 들고 있다. 복사·저장하는
내용(`full_text`)은 그와 따로, 이번 실행에서 `livesub.log` 에 쓴 부분 전체를
파일에서 다시 읽는다. 오래 켜 두면 맨 앞의 GPU 준비·모델 로드 기록이 화면에서는
밀려나는데, 원인을 찾을 때 가장 필요한 게 바로 그 부분이다.
"""
from __future__ import annotations
import logging
import threading
from collections import deque
from collections.abc import Callable
from pathlib import Path
#: 화면에 들고 있을 최대 줄 수. 한 줄 200바이트로 잡아도 1MB 남짓이다.
MAX_RECORDS = 5000
Listener = Callable[[str], None]
class LogBuffer:
"""서식을 입힌 로그 줄을 최근 것부터 `MAX_RECORDS` 개까지 들고 있는다. 스레드 안전."""
def __init__(self, limit: int = MAX_RECORDS) -> None:
self._lines: deque[str] = deque(maxlen=limit)
self._listeners: list[Listener] = []
self._lock = threading.Lock()
#: 이번 실행의 로그 파일과, 이번 실행이 쓰기 시작한 위치(바이트)
self._file: Path | None = None
self._file_offset = 0
#: 로그 파일을 열기 전(저장 위치를 고르기 전)에 남은 줄. 파일에는 없다.
self._before_file: list[str] = []
def append(self, line: str) -> None:
with self._lock:
self._lines.append(line)
listeners = list(self._listeners)
for listener in listeners:
listener(line)
def lines(self) -> list[str]:
with self._lock:
return list(self._lines)
def text(self) -> str:
return "\n".join(self.lines())
def clear(self) -> None:
"""화면용 줄만 비운다. 복사·저장할 전체 기록은 그대로 둔다."""
with self._lock:
self._lines.clear()
def attach_file(self, path: Path, offset: int) -> None:
"""이번 실행이 `path` 의 `offset` 바이트부터 로그를 쓴다고 알려 준다."""
with self._lock:
if self._file is None:
self._before_file = list(self._lines)
self._file = path
self._file_offset = offset
def full_text(self) -> str:
"""이번 실행의 로그 전체. 파일을 못 읽으면 화면에 있는 만큼이라도 준다."""
with self._lock:
path, offset, before = self._file, self._file_offset, list(self._before_file)
if path is None:
return self.text()
try:
with open(path, "rb") as f:
f.seek(offset)
raw = f.read().decode("utf-8", errors="replace")
except OSError:
return self.text()
# Windows 에서는 FileHandler 가 텍스트 모드라 줄 끝이 \r\n 이다.
written = raw.replace("\r\n", "\n").rstrip("\n")
return "\n".join([*before, written] if written else before)
def subscribe(self, listener: Listener) -> None:
"""새 줄이 들어올 때마다 불린다. 로그를 남긴 스레드에서 불리는 점에 주의."""
with self._lock:
self._listeners.append(listener)
def unsubscribe(self, listener: Listener) -> None:
with self._lock:
if listener in self._listeners:
self._listeners.remove(listener)
class BufferHandler(logging.Handler):
def __init__(self, buffer: LogBuffer) -> None:
super().__init__()
self.buffer = buffer
def emit(self, record: logging.LogRecord) -> None:
try:
self.buffer.append(self.format(record))
except Exception: # noqa: BLE001 - 로그 때문에 프로그램이 죽으면 안 된다
self.handleError(record)
#: 프로그램 전체가 쓰는 하나뿐인 버퍼. `setup_logging` 이 여기에 붙인다.
BUFFER = LogBuffer()

View File

@@ -9,7 +9,7 @@ from dataclasses import dataclass, field
import numpy as np
from ..constants import LANGUAGE_CODES, models_dir
from ..constants import LANGUAGE_CODES, SAMPLE_RATE, models_dir
from .tiers import AsrSpec
log = logging.getLogger(__name__)
@@ -27,6 +27,35 @@ ALT_LANGUAGE_MAX_LOGPROB_DROP = -0.45
#: 반복 루프는 확률이 높게 나와서 log 확률만으로는 걸러지지 않는다.
MAX_COMPRESSION_RATIO = 2.4
#: Silero 없이 다시 받은 결과를 믿는 최저 토큰당 평균 log 확률. Whisper 원본의
#: logprob_threshold 와 같은 값이다. 게임 잡음에서 나오는 "Oh." "you" 같은 환각은
#: -1.1 대로 나오고, 효과 걸린 실제 대사는 -0.3 ~ -0.8 로 나온다 (실측).
FALLBACK_MIN_LOGPROB = -1.0
#: 구간이 실제 오디오보다 이만큼(초) 넘게 끝나면 환각이다. 말소리가 없으면 Whisper 는
#: 타임스탬프를 못 찍고 30초 창 끝까지 이어진 "Thank you." 를 내놓는다.
FALLBACK_MAX_OVERRUN_S = 1.0
#: Silero 없이 다시 받을 때 말소리가 없으면 Whisper 가 지어내는 문장들. 게임 잡음·
#: 숨소리·웅웅거림을 넣으면 이 말이 나온다 (turbo 실측). 진짜 대사라면 Silero 가
#: 먼저 받아 주므로, 다시 받은 쪽에서만 버린다. 비교는 `_normalized` 로 한다.
FALLBACK_HALLUCINATIONS = frozenset(
{
"",
"you",
"okay",
"ok",
"oh",
"bye",
"thank you",
"thanks",
"thank you for watching",
"thanks for watching",
"obrigado",
"e aí",
}
)
#: 다시 받은 결과에 이 글자가 섞여 있으면 모델이 언어를 바꾸지 못한 것이다.
#: (진짜 한국어를 small 모델로 '영어로' 받으면 한글을 그대로 적는다.)
_SCRIPT = {
@@ -131,20 +160,27 @@ class SpeechRecognizer:
def _run(
self, audio: np.ndarray, language: str | None, fast: bool, prompt: str
) -> Transcript:
assert self._model is not None
with self._lock:
segments, info = self._model.transcribe(
audio.astype(np.float32, copy=False),
language=language,
beam_size=1 if fast else self.spec.beam_size,
temperature=0.0,
condition_on_previous_text=False,
initial_prompt=prompt or None,
vad_filter=not fast,
vad_parameters={"min_silence_duration_ms": 300},
word_timestamps=False,
)
segments = list(segments)
segments, info = self._decode(audio, language, fast, prompt, vad=not fast)
if not fast and not any(s.text.strip() for s in segments):
# Silero VAD 가 구간을 통째로 버렸다. 효과가 걸린 게임 목소리("Get up!
# Over here!")는 Silero 확률이 0.1 대로 나와서 여기서 사라진다. 이 구간은
# 이미 우리 분할기가 말소리로 본 것이므로 VAD 없이 한 번 더 받되, 잡음에서
# 나오는 환각("Thank you.")은 `_plausible` 로 거른다.
#
# 직전 문장(prompt)은 넘기지 않는다. 말소리가 없으면 Whisper 는 prompt 를
# 그대로 따라 적는다. 한 번 "Okay." 가 나오면 그 뒤 잡음마다 "Okay." 가
# 나와 아무 말도 없는데 자막이 계속 떴다 (잡음 8종 모두, turbo 실측).
segments, info = self._decode(audio, language, fast, "", vad=False)
duration = audio.size / SAMPLE_RATE
kept = [s for s in segments if _plausible(s, duration)]
if segments:
log.info(
"Silero 가 버린 구간을 VAD 없이 다시 받음 (%.1f초): 채택 %r · 버림 %r",
duration,
[s.text.strip() for s in kept],
[s.text.strip() for s in segments if s not in kept],
)
segments = kept
text = " ".join(s.text.strip() for s in segments if s.text.strip()).strip()
tokens = sum(len(getattr(s, "tokens", ()) or ()) for s in segments)
@@ -167,6 +203,24 @@ class SpeechRecognizer:
language_probs={str(k): float(v) for k, v in probs},
)
def _decode(
self, audio: np.ndarray, language: str | None, fast: bool, prompt: str, vad: bool
) -> tuple[list, object]:
assert self._model is not None
with self._lock:
segments, info = self._model.transcribe(
audio.astype(np.float32, copy=False),
language=language,
beam_size=1 if fast else self.spec.beam_size,
temperature=0.0,
condition_on_previous_text=False,
initial_prompt=prompt or None,
vad_filter=vad,
vad_parameters={"min_silence_duration_ms": 300} if vad else None,
word_timestamps=False,
)
return list(segments), info
def _alternative_language(
probs: dict[str, float], detected: str, supported: bool
@@ -191,6 +245,22 @@ def _most_likely(candidates: list[str], probs: dict[str, float]) -> str | None:
return max(known, key=lambda c: probs[c]) if known else None
def _plausible(segment, duration_s: float) -> bool:
"""Silero 없이 받은 구간이 실제 말소리를 받아 적은 것으로 보이는가."""
if float(getattr(segment, "end", 0.0) or 0.0) > duration_s + FALLBACK_MAX_OVERRUN_S:
return False
if float(getattr(segment, "compression_ratio", 0.0) or 0.0) > MAX_COMPRESSION_RATIO:
return False
if _normalized(segment.text) in FALLBACK_HALLUCINATIONS:
return False
return float(getattr(segment, "avg_logprob", 0.0)) >= FALLBACK_MIN_LOGPROB
def _normalized(text: str) -> str:
"""비교용으로 문장부호·대소문자·여분 공백을 없앤다. "Okay." == "okay"""
return " ".join(re.sub(r"[^\w\s]", " ", text.lower()).split())
def _accept_alternative(first: Transcript, alt: Transcript, avoided: str) -> bool:
if not alt.text:
return False

View File

@@ -0,0 +1,156 @@
"""GPU 로 받아 적고 번역할 때 필요한 cuBLAS DLL 을 준비한다 (Windows).
CTranslate2 의 Windows 패키지는 GPU 계산 때 `cublas64_12.dll` 을 이름으로 찾아
불러온다. 그런데 이 DLL 은 패키지에 들어 있지 않다. 리눅스 개발 환경에서는
torch 가 같이 깔아 둔 cuBLAS 를 쓰기 때문에 문제가 드러나지 않았고, torch 를 뺀
포터블 exe 에서는 모델은 GPU 에 잘 올라가는데 첫 문장을 받아 적는 순간부터
매번 실패했다. 소리 게이지는 움직이는데 자막이 하나도 안 나오던 원인이다.
두 DLL 이 790MB 라 exe 에 넣으면 실행할 때마다 그만큼 임시폴더에 풀어야 한다.
그래서 처음 GPU 를 쓸 때 NVIDIA 가 PyPI 에 올린 공식 패키지를 한 번 받아 모델
폴더에 둔다. CUDA Toolkit 이 깔려 있어 이미 불러올 수 있으면 받지 않는다.
"""
from __future__ import annotations
import ctypes
import hashlib
import logging
import os
import sys
import threading
import urllib.request
import zipfile
from collections.abc import Callable
from pathlib import Path
from ..constants import models_dir
log = logging.getLogger(__name__)
#: cuBLAS 12.8 부터 RTX 50 계열(Blackwell)을 지원한다.
WHEEL_VERSION = "12.8.4.1"
WHEEL_URL = (
"https://files.pythonhosted.org/packages/70/61/"
"7d7b3c70186fb651d0fbd35b01dbfc8e755f69fd58f817f3d0f642df20c3/"
"nvidia_cublas_cu12-12.8.4.1-py3-none-win_amd64.whl"
)
WHEEL_SHA256 = "47e9b82132fa8d2b4944e708049229601448aaad7e6f296f630f2d1a32de35af"
WHEEL_SIZE = 567_544_208
#: 불러오는 순서대로. cublas64_12 가 cublasLt64_12 를 import 하므로 Lt 가 먼저다.
DLLS = ("cublasLt64_12.dll", "cublas64_12.dll")
_WHEEL_DIR = "nvidia/cublas/bin/"
ProgressCallback = Callable[[str, float], None]
class DownloadCancelled(Exception):
"""사용자가 받는 도중에 번역을 정지했다."""
#: os.add_dll_directory 가 돌려준 핸들. 닫히면 검색 경로에서 빠지므로 붙잡아 둔다.
_dll_dir_handle = None
#: 불러온 DLL 핸들. 참조가 사라지면 내려갈 수 있으므로 들고 있는다.
_loaded: list = []
_ready = False
def runtime_dir() -> Path:
"""모델 폴더 안에 둔다. 저장 위치를 옮길 때 모델과 같이 따라간다."""
return models_dir() / f"cuda-runtime-cublas-{WHEEL_VERSION}"
def installed(directory: Path | None = None) -> bool:
directory = directory or runtime_dir()
return all((directory / name).is_file() for name in DLLS)
def _system_has_cublas() -> bool:
"""CUDA Toolkit 등으로 이미 이름만으로 불러올 수 있는가."""
try:
_loaded.append(ctypes.WinDLL(DLLS[-1])) # type: ignore[attr-defined]
except OSError:
return False
return True
def ensure(progress: ProgressCallback | None = None, device: str = "cuda",
cancel: threading.Event | None = None) -> bool:
"""GPU 를 쓸 수 있게 cuBLAS 를 준비한다. 새로 받았거나 불러왔으면 True.
Windows 가 아니거나 CPU 로 돌릴 때는 아무것도 하지 않는다. 받기·불러오기에
실패하면 예외를 그대로 올린다. 호출한 쪽이 CPU 로 바꿀지 정한다.
`cancel` 이 켜지면 받기를 멈추고 `DownloadCancelled` 를 올린다.
"""
global _ready
if sys.platform != "win32" or device != "cuda":
return False
if _ready:
return True
directory = runtime_dir()
if not installed(directory) and _system_has_cublas():
log.info("시스템에 있는 cuBLAS 를 씁니다.")
else:
if not installed(directory):
download(directory, progress, cancel=cancel)
activate(directory)
_ready = True
return True
def download(directory: Path, progress: ProgressCallback | None = None,
url: str = WHEEL_URL, sha256: str = WHEEL_SHA256,
size: int = WHEEL_SIZE, cancel: threading.Event | None = None) -> None:
"""공식 패키지를 받아 DLL 두 개만 꺼낸다. 끝나면 패키지 파일은 지운다."""
directory.mkdir(parents=True, exist_ok=True)
part = directory / "cublas.whl.part"
total_mb = size / 2**20
log.info("GPU 계산 파일(cuBLAS %s) 내려받기: %s", WHEEL_VERSION, url)
digest = hashlib.sha256()
done = 0
last_pct = -1
try:
with urllib.request.urlopen(url, timeout=30) as resp, part.open("wb") as out:
while chunk := resp.read(1 << 20):
if cancel is not None and cancel.is_set():
raise DownloadCancelled("GPU 계산 파일 받기를 멈췄습니다")
out.write(chunk)
digest.update(chunk)
done += len(chunk)
pct = int(done * 100 / size) if size else 0
if progress and pct != last_pct:
last_pct = pct
progress(
f"GPU 계산 파일 받는 중 (처음 한 번만) "
f"{done / 2**20:.0f}/{total_mb:.0f}MB",
min(done / size, 1.0) if size else 0.0,
)
if done != size or digest.hexdigest() != sha256:
raise RuntimeError(
f"GPU 계산 파일이 손상됐습니다 ({done}바이트, 다시 시도해 주세요)"
)
with zipfile.ZipFile(part) as wheel:
for name in DLLS:
tmp = directory / f"{name}.part"
with wheel.open(_WHEEL_DIR + name) as src, tmp.open("wb") as dst:
while block := src.read(1 << 20):
dst.write(block)
tmp.replace(directory / name)
finally:
part.unlink(missing_ok=True)
log.info("GPU 계산 파일 준비 완료: %s", directory)
def activate(directory: Path) -> None:
"""DLL 을 전체 경로로 미리 불러 둔다.
CTranslate2 는 `cublas64_12.dll` 을 이름으로만 찾는다. 같은 이름의 모듈이 이미
올라와 있으면 Windows 는 그것을 쓰므로, 검색 경로 규칙에 기대지 않아도 된다.
"""
global _dll_dir_handle
if _dll_dir_handle is None and hasattr(os, "add_dll_directory"):
_dll_dir_handle = os.add_dll_directory(str(directory))
os.environ["PATH"] = f"{directory}{os.pathsep}{os.environ.get('PATH', '')}"
for name in DLLS:
_loaded.append(ctypes.WinDLL(str(directory / name))) # type: ignore[attr-defined]
log.info("cuBLAS 불러옴: %s", directory)

View File

@@ -191,6 +191,9 @@ class ModelManager:
self.config = config
#: 저부하(게임) 모드. 연산 정밀도를 낮춰 VRAM과 GPU 점유를 줄인다.
self.low_power = low_power
#: 실제로 돌릴 장치. 설정값에서 시작하지만, GPU 가 안 되면 이번 실행만
#: CPU 로 바꾼다. 설정 파일에는 남기지 않는다 — 다음엔 GPU 가 될 수 있다.
self.device = config.device
self._tier: Tier = get_tier(config.tier)
self._asr: SpeechRecognizer | None = None
self._mt: Translator | None = None
@@ -224,7 +227,7 @@ class ModelManager:
with self._lock:
if self._asr is None:
self._asr = SpeechRecognizer(
self.effective_asr_spec(), self.config.device, self.config.device_index
self.effective_asr_spec(), self.device, self.config.device_index
)
return self._asr
@@ -233,7 +236,7 @@ class ModelManager:
if self._mt is None:
self._mt = create_translator(
self.effective_mt_spec(),
self.config.device,
self.device,
self.config.device_index,
self.config.lora_adapter_path,
)
@@ -251,6 +254,15 @@ class ModelManager:
self.translator().load()
report("준비 완료", 1.0)
def use_device(self, device: str) -> bool:
"""돌릴 장치를 바꾼다. 바뀌었으면 올라가 있던 모델을 내리고 True."""
if device == self.device:
return False
self.unload()
self.device = device
log.info("연산 장치 변경: %s", device)
return True
def switch_tier(self, tier_key: str) -> Tier:
"""티어 변경. 기존 모델은 내려서 VRAM을 즉시 돌려준다."""
if tier_key == self._tier.key:

View File

@@ -30,7 +30,7 @@ from ..constants import APP_NAME, APP_SLOGAN, APP_VERSION, user_data_dir
from ..core import EngineState, EngineStatus, TranslationEngine, TranslationLine
from .hotkeys import GlobalHotkeys
from .overlay import SubtitleOverlay
from .pages import GlossaryPage, HomePage, ModelsPage, SettingsPage, SubtitlePage
from .pages import GlossaryPage, HomePage, LogPage, ModelsPage, SettingsPage, SubtitlePage
from .theme import SPACING, palette, stylesheet
log = logging.getLogger(__name__)
@@ -41,6 +41,7 @@ NAV = [
("자막", "표시 설정"),
("용어집", "고유명사 고정"),
("설정", "세부 조정"),
("로그", "전체 기록 · 복사/저장"),
]
@@ -73,6 +74,14 @@ class MainWindow(QMainWindow):
self._save_timer.setInterval(800) # 입력 중 계속 쓰지 않도록 묶어서 저장
self._save_timer.timeout.connect(lambda: self.config.save())
# 입력 게이지는 상태 이벤트가 아니라 타이머로 엔진 값을 읽어 그린다.
# 상태 이벤트는 시작·정지 때만 나가서 번역 중에는 게이지가 멈춰 있었다.
self._level_timer = QTimer(self)
self._level_timer.setInterval(33) # 약 30Hz
self._level_timer.timeout.connect(
lambda: self.home_page.set_input_level(self.engine.level)
)
# --- UI -------------------------------------------------------------
def _build_ui(self) -> None:
self.setStyleSheet(stylesheet(self.config.theme))
@@ -89,12 +98,14 @@ class MainWindow(QMainWindow):
self.subtitle_page = SubtitlePage(self.config)
self.glossary_page = GlossaryPage(self.config)
self.settings_page = SettingsPage(self.config)
self.log_page = LogPage(self.config)
for page in (
self.home_page,
self.models_page,
self.subtitle_page,
self.glossary_page,
self.settings_page,
self.log_page,
):
self.stack.addWidget(_scrollable(page))
layout.addWidget(self.stack, 1)
@@ -257,6 +268,10 @@ class MainWindow(QMainWindow):
def _on_status(self, status: EngineStatus) -> None:
self.home_page.on_status(status)
if status.state is EngineState.RUNNING:
self._level_timer.start()
else:
self._level_timer.stop()
if status.state is EngineState.ERROR:
QMessageBox.warning(self, "오류", status.message)

View File

@@ -1,7 +1,8 @@
from .glossary_page import GlossaryPage
from .home import HomePage
from .log_page import LogPage
from .models_page import ModelsPage
from .settings_page import SettingsPage
from .subtitle_page import SubtitlePage
__all__ = ["GlossaryPage", "HomePage", "ModelsPage", "SettingsPage", "SubtitlePage"]
__all__ = ["GlossaryPage", "HomePage", "LogPage", "ModelsPage", "SettingsPage", "SubtitlePage"]

View File

@@ -25,6 +25,7 @@ from ...constants import LANGUAGES
from ...core.events import EngineState, EngineStatus, TranslationLine
from ..theme import SPACING, palette
from ..widgets import Card, LevelMeter, PageHeader, StatusPill
from ..widgets.common import METER_AUDIBLE_DB, level_to_db
MAX_LOG_ROWS = 300
@@ -157,10 +158,49 @@ class HomePage(QWidget):
layout.addWidget(self.toggle_button)
card.add(row)
self.level_meter = LevelMeter()
card.add(self.level_meter)
card.add(self._build_level_row())
return card
def _build_level_row(self) -> QWidget:
"""소리를 제대로 받고 있는지 보여주는 입력 게이지."""
row = QWidget()
layout = QHBoxLayout(row)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(12)
layout.addWidget(QLabel("입력 소리"))
self.level_meter = LevelMeter()
self.level_meter.setToolTip(
"선택한 프로그램(또는 마이크)에서 받고 있는 소리 크기입니다.\n"
"말소리가 나는데 게이지가 안 움직이면 '소리 받아올 곳'을 다시 고르세요."
)
layout.addWidget(self.level_meter, 1)
self.level_label = QLabel()
self.level_label.setObjectName("Hint")
self.level_label.setMinimumWidth(150)
layout.addWidget(self.level_label)
self._quiet_ticks = 0
self._set_level_text("번역을 시작하면 움직입니다")
return row
def _set_level_text(self, text: str) -> None:
if self.level_label.text() != text:
self.level_label.setText(text)
#: '소리 없음'으로 바꾸기 전에 기다리는 갱신 횟수 (약 30Hz 기준 1.5초).
#: 말 사이 짧은 숨까지 '소리 없음'으로 깜빡이지 않게 한다.
QUIET_TICKS = 45
def set_input_level(self, rms: float) -> None:
"""번역 중 주기적으로 불린다. 게이지와 옆 문구를 갱신한다."""
self.level_meter.set_level(rms)
if level_to_db(rms) >= METER_AUDIBLE_DB:
self._quiet_ticks = 0
self._set_level_text("소리 받는 중")
return
self._quiet_ticks += 1
if self._quiet_ticks >= self.QUIET_TICKS:
self._set_level_text("소리 없음")
def _build_log_card(self) -> Card:
card = Card("최근 자막", "확정된 문장이 위로 쌓입니다. 지연 시간도 함께 보여줍니다.")
self.log_list = QListWidget()
@@ -275,7 +315,14 @@ class HomePage(QWidget):
EngineState.ERROR: "error",
}.get(status.state, "idle")
self.status_pill.set_status(status.message or status.state.value, kind)
self.level_meter.set_level(status.level)
if status.state is not EngineState.RUNNING:
self.level_meter.reset()
self._quiet_ticks = 0
self._set_level_text(
"모델 준비 중…"
if status.state is EngineState.LOADING
else "번역을 시작하면 움직입니다"
)
for widget in (
self.source_combo,

View File

@@ -0,0 +1,148 @@
"""로그 — 프로그램을 켠 뒤 남은 기록 전체. 복사하거나 파일로 저장해 보낼 수 있다."""
from __future__ import annotations
import platform
from datetime import datetime
from PySide6.QtCore import Signal
from PySide6.QtGui import QFontDatabase, QGuiApplication
from PySide6.QtWidgets import (
QFileDialog,
QHBoxLayout,
QLabel,
QPlainTextEdit,
QPushButton,
QVBoxLayout,
QWidget,
)
from ...config import AppConfig
from ...constants import APP_NAME, APP_VERSION, user_data_dir
from ...log_buffer import BUFFER, MAX_RECORDS, LogBuffer
from ..theme import SPACING
from ..widgets import Card, PageHeader
class LogPage(QWidget):
#: 로그는 아무 스레드에서나 들어오므로 시그널로 GUI 스레드에 넘긴다.
line_logged = Signal(str)
def __init__(
self, config: AppConfig, buffer: LogBuffer = BUFFER, parent: QWidget | None = None
):
super().__init__(parent)
self.config = config
self.buffer = buffer
root = QVBoxLayout(self)
root.setContentsMargins(0, 0, 0, 0)
root.setSpacing(SPACING + 4)
root.addWidget(
PageHeader(
"로그",
"프로그램을 켠 뒤 남은 기록 전체입니다. 문제가 생기면 '복사'나 "
"'파일로 저장'을 눌러 그대로 보내 주세요.",
)
)
card = Card()
buttons = QWidget()
row = QHBoxLayout(buttons)
row.setContentsMargins(0, 0, 0, 0)
row.setSpacing(10)
self.copy_button = QPushButton("복사")
self.copy_button.setObjectName("Primary")
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.save_button = QPushButton("파일로 저장")
self.save_button.clicked.connect(self._save_dialog)
self.clear_button = QPushButton("화면 비우기")
self.clear_button.setToolTip(
"이 화면만 비웁니다. 복사·저장에는 이번 실행 기록이 전부 그대로 들어갑니다."
)
self.clear_button.clicked.connect(self.clear)
for button in (self.copy_button, self.save_button, self.clear_button):
row.addWidget(button)
row.addStretch(1)
self.notice = QLabel()
self.notice.setObjectName("Hint")
row.addWidget(self.notice)
card.add(buttons)
self.view = QPlainTextEdit()
self.view.setReadOnly(True)
self.view.setLineWrapMode(QPlainTextEdit.LineWrapMode.WidgetWidth)
self.view.setMaximumBlockCount(MAX_RECORDS)
self.view.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
self.view.setMinimumHeight(520)
card.add(self.view)
root.addWidget(card, 1)
self.view.setPlainText(buffer.text())
self.line_logged.connect(self._append)
signal = self.line_logged
def forward(line: str) -> None:
try:
signal.emit(line)
except RuntimeError: # 창이 이미 사라졌다
buffer.unsubscribe(forward)
self._forward = forward
buffer.subscribe(forward)
# --- 동작 -----------------------------------------------------------
def report(self) -> str:
"""보낼 내용 전체. 맨 위에 실행 환경을 붙여서 로그만 봐도 상황을 알게 한다."""
models = self.config.models
audio = self.config.audio
header = [
f"{APP_NAME} v{APP_VERSION} · {platform.platform()} · Python {platform.python_version()}",
f"티어 {models.tier} · 장치 {models.device} · 원본 {models.source_lang} → "
f"번역 {models.target_lang} · 소리 {audio.backend}"
f"{' ' + audio.target_process_name if audio.backend == 'process' else ''}",
f"저장 위치 {user_data_dir()} · 기록 시각 {datetime.now():%Y-%m-%d %H:%M:%S}",
"-" * 60,
]
return "\n".join(header) + "\n" + self.buffer.full_text() + "\n"
def copy_to_clipboard(self) -> None:
text = self.report()
QGuiApplication.clipboard().setText(text)
self.notice.setText(f"{text.count(chr(10))}줄을 복사했습니다")
def save_to(self, path: str) -> None:
with open(path, "w", encoding="utf-8") as f:
f.write(self.report())
self.notice.setText(f"저장했습니다: {path}")
def _save_dialog(self) -> None:
default = user_data_dir() / datetime.now().strftime("livesub-log-%Y%m%d-%H%M%S.txt")
path, _ = QFileDialog.getSaveFileName(
self, "로그 저장", str(default), "텍스트 파일 (*.txt)"
)
if not path:
return
try:
self.save_to(path)
except OSError as exc:
self.notice.setText(f"저장하지 못했습니다: {exc}")
def clear(self) -> None:
self.buffer.clear()
self.view.clear()
self.notice.setText("")
def _append(self, line: str) -> None:
bar = self.view.verticalScrollBar()
at_bottom = bar.value() >= bar.maximum() - 4
self.view.appendPlainText(line)
# 위로 올려 읽는 중이면 끌어내리지 않는다.
if at_bottom:
bar.setValue(bar.maximum())
def showEvent(self, event) -> None: # noqa: N802
# 숨어 있는 동안 쌓인 줄은 스크롤 위치를 못 맞춘다. 열 때 최신 줄로 내린다.
super().showEvent(event)
bar = self.view.verticalScrollBar()
bar.setValue(bar.maximum())

View File

@@ -2,6 +2,8 @@
from __future__ import annotations
import math
from PySide6.QtCore import Qt
from PySide6.QtGui import QColor, QPainter
from PySide6.QtWidgets import (
@@ -98,20 +100,68 @@ class StatusPill(QLabel):
)
#: 게이지 왼쪽 끝(dBFS). 이보다 작은 소리는 바닥으로 본다.
METER_FLOOR_DB = -60.0
#: 이 이상이면 '소리 들림'. 게임 배경음·대사는 보통 -40 ~ -15 dBFS 사이다.
METER_AUDIBLE_DB = -50.0
def level_to_db(rms: float) -> float:
"""RMS(0~1)를 dBFS로. 0이면 바닥값."""
if rms <= 0.0:
return METER_FLOOR_DB
return max(METER_FLOOR_DB, min(0.0, 20.0 * math.log10(rms)))
def level_to_fraction(rms: float) -> float:
"""RMS를 게이지 채움 비율(0~1)로.
소리 크기는 로그로 느끼므로 dB로 펴서 그린다. RMS를 그대로 그리면
평범한 게임 대사(-30 dBFS ≈ 0.03)가 게이지의 3%밖에 안 차서 멈춘 것처럼 보인다.
"""
return (level_to_db(rms) - METER_FLOOR_DB) / -METER_FLOOR_DB
class LevelMeter(QWidget):
"""입력 오디오 레벨 바. 소리가 잡히는지 한눈에 확인하는 용도."""
"""입력 오디오 레벨 바. 소리가 잡히는지 한눈에 확인하는 용도.
올라갈 때는 바로, 내려갈 때는 천천히 따라가서 말소리에 맞춰 출렁인다.
최근 최고점은 얇은 세로선으로 잠깐 남겨 둔다.
"""
#: set_level 한 번마다 내려가는 양 (약 30Hz 갱신 기준 0.5초에 바닥)
RELEASE_STEP = 0.06
#: 최고점 표시를 붙잡아 두는 갱신 횟수
PEAK_HOLD_TICKS = 25
def __init__(self, parent: QWidget | None = None):
super().__init__(parent)
self._level = 0.0
self._peak = 0.0
self.setFixedHeight(8)
self._peak_ticks = 0
self.setFixedHeight(12)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
def set_level(self, value: float) -> None:
# RMS를 그대로 그리면 거의 안 움직여서 제곱근으로 펴준다.
self._level = min(1.0, max(0.0, value) ** 0.5 * 2.2)
self._peak = max(self._level, self._peak * 0.92)
@property
def level(self) -> float:
"""지금 그려진 채움 비율(0~1)."""
return self._level
def set_level(self, rms: float) -> None:
target = level_to_fraction(rms)
self._level = max(target, self._level - self.RELEASE_STEP)
if self._level >= self._peak:
self._peak = self._level
self._peak_ticks = self.PEAK_HOLD_TICKS
elif self._peak_ticks > 0:
self._peak_ticks -= 1
else:
self._peak = max(self._level, self._peak - self.RELEASE_STEP / 2)
self.update()
def reset(self) -> None:
self._level = self._peak = 0.0
self._peak_ticks = 0
self.update()
def paintEvent(self, event) -> None: # noqa: N802
@@ -120,12 +170,22 @@ class LevelMeter(QWidget):
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(QColor(p.surface_alt))
painter.drawRoundedRect(self.rect(), 4, 4)
painter.drawRoundedRect(self.rect(), 5, 5)
width = self.width()
if self._level > 0.01:
color = QColor(p.danger if self._level > 0.92 else p.success)
rect = self.rect().adjusted(0, 0, -int(self.width() * (1 - self._level)), 0)
painter.setBrush(color)
painter.drawRoundedRect(rect, 4, 4)
# 0 dBFS 근처면 소리가 찌그러질 만큼 크다는 뜻이라 색으로 알려준다.
if self._level > 0.95:
color = p.danger
elif self._level > 0.85:
color = p.warning
else:
color = p.success
painter.setBrush(QColor(color))
painter.drawRoundedRect(0, 0, max(6, int(width * self._level)), self.height(), 5, 5)
if self._peak > 0.02:
x = min(width - 2, int(width * self._peak))
painter.setBrush(QColor(p.text))
painter.drawRect(x, 1, 2, self.height() - 2)
def labelled_row(label: str, widget: QWidget) -> QWidget:

21
tests/conftest.py Normal file
View File

@@ -0,0 +1,21 @@
"""모든 테스트 공통 설정."""
from __future__ import annotations
from types import SimpleNamespace
import pytest
@pytest.fixture(autouse=True)
def _no_cublas_download(monkeypatch):
"""엔진 테스트가 Windows 에서 cuBLAS(541MB)를 실제로 받지 않게 한다.
기본 설정이 device=cuda 라 엔진을 띄우면 Windows 에서는 시작 때 cuBLAS 를
준비한다. 그러면 시작이 느려져 시간 제한이 있는 테스트가 실패한다. 엔진이
붙잡은 모듈 참조만 바꾸므로 `test_cuda_runtime` 은 진짜 모듈을 그대로 본다.
"""
monkeypatch.setattr(
"livesub.core.engine.cuda_runtime",
SimpleNamespace(ensure=lambda *args, **kwargs: False),
)

View File

@@ -5,6 +5,7 @@ from __future__ import annotations
from types import SimpleNamespace
import numpy as np
import pytest
from livesub.models.asr import SpeechRecognizer
from livesub.models.tiers import AsrSpec
@@ -144,3 +145,85 @@ def test_unsupported_language_falls_back_to_best_supported():
)
t = recognizer(fake).transcribe(AUDIO, target_lang="ko")
assert (t.language, t.text) == ("en", "Nice shot")
class SileroDropsWhisper:
"""Silero VAD 를 켜면 아무것도 못 받고, 끄면 정해 둔 구간을 돌려준다."""
def __init__(self, segments):
self.segments = segments
self.vad_calls: list[bool] = []
self.prompts: list[str | None] = []
def transcribe(self, audio, language=None, vad_filter=False, initial_prompt=None, **_):
self.vad_calls.append(vad_filter)
self.prompts.append(initial_prompt)
info = SimpleNamespace(
language="en", language_probability=0.9, duration=audio.size / 16_000,
all_language_probs=[("en", 0.9)],
)
return iter([] if vad_filter else self.segments), info
def raw(text: str, end: float, logprob: float, ratio: float = 1.0):
s = seg(text, logprob)
s.end = end
s.compression_ratio = ratio
return s
# 실측값 (large-v3-turbo, 사용자 게임 녹음 5.2초 구간). Silero 확률이 0.14 라 통째로 버려졌다.
EFFECT_VOICE = [raw(" Get up!", 2.0, -0.73), raw(" Over here!", 4.0, -0.73)]
FIVE_SECONDS = np.zeros(5 * 16_000, dtype=np.float32)
def test_voice_dropped_by_silero_is_recovered_without_vad():
fake = SileroDropsWhisper(EFFECT_VOICE)
t = recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko")
assert t.text == "Get up! Over here!"
assert fake.vad_calls == [True, False]
def test_noise_hallucination_running_to_window_end_is_dropped():
"""말소리가 없으면 30초 창 끝까지 이어진 'Thank you.' 가 나온다 (turbo 실측)."""
fake = SileroDropsWhisper([raw(" Thank you.", 29.98, -0.77)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_low_confidence_noise_word_is_dropped():
fake = SileroDropsWhisper([raw(" Oh.", 0.5, -1.12)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_repetition_without_vad_is_dropped():
fake = SileroDropsWhisper([raw(" විවිවිවිවිවිවිවි", 3.8, -0.26, ratio=6.0)])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_retry_without_vad_does_not_echo_previous_line():
"""말소리가 없으면 Whisper 는 prompt 를 따라 적는다. 다시 받을 때는 넘기지 않는다."""
fake = SileroDropsWhisper(EFFECT_VOICE)
recognizer(fake).transcribe(FIVE_SECONDS, prompt="Okay.", target_lang="ko")
assert fake.prompts == ["Okay.", None]
# 실측값 (turbo, 잡음만 넣고 Silero 없이 받음). 모두 확률·길이 기준을 통과한다.
@pytest.mark.parametrize(
"noise",
[
raw(" Okay.", 2.0, -0.76), # 직전 자막 "Okay." 를 prompt 로 줬을 때
raw(" Obrigado.", 1.0, -0.31),
raw(" you", 3.0, -0.95),
],
ids=["okay", "obrigado", "you"],
)
def test_stock_hallucination_without_vad_is_dropped(noise):
fake = SileroDropsWhisper([noise])
assert recognizer(fake).transcribe(FIVE_SECONDS, target_lang="ko").text == ""
def test_partial_results_never_retry():
"""중간 결과는 원래 VAD 없이 한 번만 받는다."""
fake = SileroDropsWhisper(EFFECT_VOICE)
recognizer(fake).transcribe(FIVE_SECONDS, fast=True, target_lang="ko")
assert fake.vad_calls == [False]

View File

@@ -0,0 +1,76 @@
"""cuBLAS 내려받기·꺼내기 (Windows exe 에서 GPU 로 받아 적는 데 필요)."""
from __future__ import annotations
import hashlib
import zipfile
import pytest
from livesub.models import cuda_runtime
def _fake_wheel(tmp_path):
wheel = tmp_path / "fake.whl"
with zipfile.ZipFile(wheel, "w") as zf:
zf.writestr("nvidia/cublas/bin/cublasLt64_12.dll", b"LT" * 1000)
zf.writestr("nvidia/cublas/bin/cublas64_12.dll", b"BLAS" * 1000)
zf.writestr("nvidia/cublas/bin/nvblas64_12.dll", b"unused")
zf.writestr("nvidia/cublas/include/cublas.h", b"header")
data = wheel.read_bytes()
return wheel.as_uri(), hashlib.sha256(data).hexdigest(), len(data)
def test_download_extracts_only_the_two_dlls(tmp_path):
url, sha, size = _fake_wheel(tmp_path)
target = tmp_path / "runtime"
seen = []
cuda_runtime.download(target, lambda msg, pct: seen.append(pct), url, sha, size)
assert cuda_runtime.installed(target)
assert (target / "cublasLt64_12.dll").read_bytes() == b"LT" * 1000
assert (target / "cublas64_12.dll").read_bytes() == b"BLAS" * 1000
assert sorted(p.name for p in target.iterdir()) == ["cublas64_12.dll", "cublasLt64_12.dll"]
assert seen and seen[-1] == 1.0
def test_corrupted_download_leaves_nothing_behind(tmp_path):
url, _sha, size = _fake_wheel(tmp_path)
target = tmp_path / "runtime"
with pytest.raises(RuntimeError, match="손상"):
cuda_runtime.download(target, None, url, "0" * 64, size)
assert not cuda_runtime.installed(target)
assert list(target.iterdir()) == []
def test_pinned_wheel_is_the_blackwell_capable_cublas():
# RTX 50 계열(sm_120)은 cuBLAS 12.8 부터 지원한다.
major, minor = (int(x) for x in cuda_runtime.WHEEL_VERSION.split(".")[:2])
assert (major, minor) >= (12, 8)
assert cuda_runtime.WHEEL_VERSION in cuda_runtime.WHEEL_URL
assert cuda_runtime.WHEEL_URL.endswith("win_amd64.whl")
def test_ensure_is_a_no_op_off_windows_or_on_cpu(monkeypatch):
monkeypatch.setattr(cuda_runtime.sys, "platform", "linux")
assert cuda_runtime.ensure(device="cuda") is False
monkeypatch.setattr(cuda_runtime.sys, "platform", "win32")
assert cuda_runtime.ensure(device="cpu") is False
def test_download_stops_when_cancelled(tmp_path):
import threading
url, sha, size = _fake_wheel(tmp_path)
target = tmp_path / "runtime"
cancel = threading.Event()
cancel.set()
with pytest.raises(cuda_runtime.DownloadCancelled):
cuda_runtime.download(target, None, url, sha, size, cancel=cancel)
assert not cuda_runtime.installed(target)
assert list(target.iterdir()) == []

156
tests/test_level_meter.py Normal file
View File

@@ -0,0 +1,156 @@
"""홈 화면 입력 소리 게이지 — 엔진이 레벨을 내주고, UI가 번역 중 계속 그리는지."""
from __future__ import annotations
import os
import time
import numpy as np
import pytest
from livesub.audio.base import CaptureBackend
from livesub.config import AppConfig
from livesub.constants import SAMPLE_RATE
from livesub.core.engine import TranslationEngine
pytest.importorskip("PySide6")
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6.QtWidgets import QApplication # noqa: E402
from livesub.core.events import EngineState, EngineStatus # noqa: E402
from livesub.ui.main_window import MainWindow # noqa: E402
from livesub.ui.widgets.common import LevelMeter, level_to_fraction # noqa: E402
class BurstCapture(CaptureBackend):
"""0.6초 동안 소리를 내고 그 뒤로는 프레임을 아예 보내지 않는다.
프로그램이 소리를 멈추면 프로그램별 캡처는 프레임이 끊길 수 있다.
"""
name = "burst"
@staticmethod
def available() -> bool:
return True
@staticmethod
def list_sources():
return []
def _run(self) -> None:
n = SAMPLE_RATE // 50 # 20ms
t = np.arange(n, dtype=np.float32) / SAMPLE_RATE
frame = (np.sin(2 * np.pi * 300 * t) * 0.3).astype(np.float32)
for _ in range(30):
if self._stop.is_set():
return
self._emit(frame.copy())
time.sleep(0.02)
self._stop.wait()
@pytest.fixture
def engine(tmp_path, monkeypatch):
config = AppConfig()
config.models.preload_on_start = False
config.glossary.path = str(tmp_path / "glossary.json")
eng = TranslationEngine(config)
monkeypatch.setattr("livesub.core.engine.create_capture", lambda cfg: BurstCapture())
yield eng
eng.shutdown()
def _wait_for(cond, timeout=3.0) -> bool:
deadline = time.time() + timeout
while time.time() < deadline:
if cond():
return True
time.sleep(0.02)
return False
def test_engine_level_follows_audio_and_drops_when_frames_stop(engine):
assert engine.level == 0.0
engine.start()
# 진폭 0.3 사인파의 RMS ≈ 0.21
assert _wait_for(lambda: engine.level > 0.15), "소리가 나는데 레벨이 오르지 않았습니다"
assert _wait_for(lambda: engine.level == 0.0), "프레임이 끊겼는데 레벨이 남아 있습니다"
engine.stop()
assert engine.level == 0.0
def test_engine_level_resets_on_stop(engine):
engine.start()
assert _wait_for(lambda: engine.level > 0.15)
engine.stop()
assert engine.level == 0.0
def test_level_to_fraction_uses_db_scale():
assert level_to_fraction(0.0) == 0.0
assert level_to_fraction(1.0) == pytest.approx(1.0)
# 평범한 게임 대사 크기(-30 dBFS)가 게이지 절반을 채워야 눈에 띈다.
assert level_to_fraction(10 ** (-30 / 20)) == pytest.approx(0.5)
assert level_to_fraction(1e-6) == 0.0 # 바닥 아래는 0
@pytest.fixture(scope="module")
def qapp():
return QApplication.instance() or QApplication([])
def test_meter_jumps_up_and_falls_back_slowly(qapp):
meter = LevelMeter()
meter.set_level(0.1)
high = meter.level
assert high == pytest.approx(level_to_fraction(0.1))
meter.set_level(0.0)
assert 0.0 < meter.level < high # 바로 떨어지지 않고 서서히
for _ in range(40):
meter.set_level(0.0)
assert meter.level == 0.0
@pytest.fixture
def window(qapp, tmp_path, monkeypatch):
monkeypatch.setattr("livesub.constants.user_data_dir", lambda: tmp_path)
config = AppConfig()
config.models.preload_on_start = False
config.glossary.path = str(tmp_path / "glossary.json")
win = MainWindow(config)
yield win
win.engine.shutdown()
win.overlay.close()
win.close()
def test_gauge_is_polled_only_while_running(window):
assert not window._level_timer.isActive()
window._on_status(EngineStatus(EngineState.RUNNING, "듣는 중"))
assert window._level_timer.isActive()
window._on_status(EngineStatus(EngineState.IDLE, "대기 중"))
assert not window._level_timer.isActive()
def test_timer_tick_moves_gauge_and_label(window, monkeypatch):
home = window.home_page
window._on_status(EngineStatus(EngineState.RUNNING, "듣는 중"))
monkeypatch.setattr(window.engine, "_level", 0.05)
window._level_timer.timeout.emit()
assert home.level_meter.level > 0.5
assert home.level_label.text() == "소리 받는 중"
# 말 사이 짧은 숨에는 문구가 바뀌지 않는다.
monkeypatch.setattr(window.engine, "_level", 0.0)
for _ in range(5):
window._level_timer.timeout.emit()
assert home.level_label.text() == "소리 받는 중"
for _ in range(home.QUIET_TICKS):
window._level_timer.timeout.emit()
assert home.level_label.text() == "소리 없음"
window._on_status(EngineStatus(EngineState.IDLE, "대기 중"))
assert home.level_meter.level == 0.0
assert home.level_label.text() == "번역을 시작하면 움직입니다"

45
tests/test_log_buffer.py Normal file
View File

@@ -0,0 +1,45 @@
"""'로그' 화면의 복사·저장이 화면 줄 수 제한과 상관없이 이번 실행 기록 전체를 담는지."""
from __future__ import annotations
import logging
import pytest
import livesub.app as app
from livesub.log_buffer import LogBuffer
@pytest.fixture
def small_buffer(tmp_path, monkeypatch):
buffer = LogBuffer(limit=3)
monkeypatch.setattr(app, "BUFFER", buffer)
monkeypatch.setattr(app, "user_data_dir", lambda: tmp_path)
yield buffer
root = logging.getLogger()
for handler in list(root.handlers):
root.removeHandler(handler)
handler.close()
def test_export_keeps_whole_run_beyond_screen_limit(small_buffer, tmp_path):
(tmp_path / "livesub.log").write_text("지난 실행 기록\n", encoding="utf-8")
log = logging.getLogger("livesub.test")
app.setup_logging(to_file=False) # 저장 위치를 고르기 전
log.info("저장 위치 고르기 전")
app.setup_logging()
for i in range(10):
log.info("줄 %d", i)
assert len(small_buffer.lines()) == 3 # 화면은 최근 것만
exported = small_buffer.full_text()
assert "저장 위치 고르기 전" in exported
assert all(f"줄 {i}" in exported for i in range(10))
assert "지난 실행 기록" not in exported
def test_export_falls_back_to_screen_lines_without_log_file(small_buffer):
app.setup_logging(to_file=False)
logging.getLogger("livesub.test").warning("파일 없음")
assert "파일 없음" in small_buffer.full_text()

View File

@@ -2,6 +2,7 @@
from __future__ import annotations
import threading
import time
import numpy as np
@@ -129,3 +130,126 @@ def test_to_mono_16k_passthrough_when_already_correct():
mono = np.linspace(-1, 1, 16_000, dtype=np.float32)
out = to_mono_16k(mono, channels=1, src_rate=16_000)
assert np.array_equal(out, mono)
class CublasMissingRecognizer(FakeRecognizer):
"""Windows exe 에서 cuBLAS 가 없을 때 CTranslate2 가 내는 오류를 흉내 낸다."""
def transcribe(self, *args, **kwargs):
raise RuntimeError("Library cublas64_12.dll is not found or cannot be loaded")
def _wait_for(predicate, timeout=12.0):
deadline = time.time() + timeout
while time.time() < deadline and not predicate():
time.sleep(0.05)
return predicate()
def test_gpu_failure_falls_back_to_cpu_and_still_produces_lines(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
monkeypatch.setattr(
engine.models,
"recognizer",
lambda: CublasMissingRecognizer() if engine.models.device == "cuda" else FakeRecognizer(),
)
assert engine.models.device == "cuda"
engine.start()
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
engine.stop()
assert engine.models.device == "cpu"
assert engine.config.models.device == "cuda", "설정 파일 값은 그대로 둬야 한다"
assert any("CPU로" in s.message and "cublas" in s.message for s in statuses)
def test_non_gpu_failure_is_shown_on_status(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
class Broken(FakeRecognizer):
def transcribe(self, *args, **kwargs):
raise ValueError("토크나이저가 깨졌습니다")
monkeypatch.setattr(engine.models, "recognizer", lambda: Broken())
engine.start()
assert _wait_for(lambda: any("문장 처리 실패" in s.message for s in statuses))
engine.stop()
assert engine.models.device == "cuda", "GPU 와 상관없는 오류로 CPU 로 바꾸면 안 된다"
assert any("토크나이저가 깨졌습니다" in s.message for s in statuses)
def test_gpu_runtime_download_failure_runs_on_cpu(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
def fail(*args, **kwargs):
raise OSError("네트워크 연결 없음")
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", fail)
engine.start()
assert _wait_for(lambda: engine.lines)
engine.stop()
assert engine.models.device == "cpu"
running = [s for s in statuses if s.state.value == "running"]
assert running and "GPU 계산 파일을 받지 못했습니다" in running[0].message
def test_gpu_failure_while_preloading_falls_back_to_cpu(engine, monkeypatch):
"""기본값(preload_on_start=True)에서 GPU 로 모델이 안 올라가도 CPU 로 시작한다."""
statuses = []
engine._on_status = statuses.append
engine.config.models.preload_on_start = True
devices = []
def preload(progress=None):
devices.append(engine.models.device)
if engine.models.device == "cuda":
raise RuntimeError("CUDA failed with error no CUDA-capable device is detected")
monkeypatch.setattr(engine.models, "preload", preload)
engine.start()
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
engine.stop()
assert devices == ["cuda", "cpu"]
assert not any(s.state.value == "error" for s in statuses)
running = [s for s in statuses if s.state.value == "running"]
assert running and "CPU로" in running[0].message
def test_stop_while_downloading_gpu_runtime_never_starts_capture(engine, monkeypatch):
"""cuBLAS 를 받는 중에 정지하면 받기를 멈추고, 캡처를 켜지 않는다."""
from livesub.models.cuda_runtime import DownloadCancelled
statuses = []
engine._on_status = statuses.append
downloading = threading.Event()
captures = []
def slow_download(progress=None, device="cuda", cancel=None):
downloading.set()
while not cancel.is_set():
progress("GPU 계산 파일 받는 중", 0.1)
time.sleep(0.05)
raise DownloadCancelled("멈춤")
def make_capture(cfg):
captures.append(cfg)
return FakeCapture()
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", slow_download)
monkeypatch.setattr("livesub.core.engine.create_capture", make_capture)
engine.start()
assert downloading.wait(5)
engine.stop()
boot_done = _wait_for(lambda: not any(t.name == "engine-boot" for t in threading.enumerate()), 5)
time.sleep(0.3)
assert boot_done, "정지했는데 시작 작업이 끝나지 않았습니다"
assert captures == [], "정지한 뒤에 캡처가 켜졌습니다"
assert engine.status.state.value == "idle"
assert statuses[-1].state.value == "idle"
assert engine.models.device == "cuda", "정지는 GPU 실패가 아니다"

View File

@@ -133,7 +133,7 @@ def test_app_window_builds_without_torch(tmp_path, monkeypatch):
cfg.glossary.path = str(tmp_path / "g.json")
win = MainWindow(cfg)
try:
assert win.stack.count() == 5
assert win.stack.count() == 6
finally:
win.engine.shutdown()
win.overlay.close()

View File

@@ -40,11 +40,11 @@ def window(qapp, tmp_path, monkeypatch):
def test_main_window_builds_all_pages(window):
assert window.stack.count() == 5
assert window.stack.count() == 6
def test_navigation_switches_pages(window):
for index in range(5):
for index in range(6):
window._goto_page(index)
assert window.stack.currentIndex() == index
@@ -71,6 +71,34 @@ def test_partial_line_is_not_logged(window):
assert window.home_page.log_list.count() == 0
def test_log_page_shows_and_exports_app_logs(window, qapp, tmp_path):
"""엔진 스레드에서 남긴 로그가 로그 화면에 뜨고, 복사·저장 내용에 들어간다."""
import logging
import threading
from livesub.app import setup_logging
setup_logging(to_file=False)
worker = threading.Thread(
target=lambda: logging.getLogger("livesub.core.engine").warning("구간 처리 실패: 테스트")
)
worker.start()
worker.join()
qapp.processEvents()
page = window.log_page
assert "구간 처리 실패: 테스트" in page.view.toPlainText()
page.copy_to_clipboard()
copied = qapp.clipboard().text()
assert copied.startswith("LiveSub v")
assert "구간 처리 실패: 테스트" in copied
out = tmp_path / "log.txt"
page.save_to(str(out))
assert "구간 처리 실패: 테스트" in out.read_text(encoding="utf-8")
def test_tier_selection_updates_config(window):
window.models_page._on_tier_selected(window.models_page._cards[3].tier)
assert window.config.models.tier == "precision"