2 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
11 changed files with 421 additions and 12 deletions

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

@@ -399,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,

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

@@ -36,6 +36,26 @@ FALLBACK_MIN_LOGPROB = -1.0
#: 타임스탬프를 못 찍고 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 = {
@@ -146,9 +166,21 @@ class SpeechRecognizer:
# Over here!")는 Silero 확률이 0.1 대로 나와서 여기서 사라진다. 이 구간은
# 이미 우리 분할기가 말소리로 본 것이므로 VAD 없이 한 번 더 받되, 잡음에서
# 나오는 환각("Thank you.")은 `_plausible` 로 거른다.
segments, info = self._decode(audio, language, fast, prompt, vad=False)
#
# 직전 문장(prompt)은 넘기지 않는다. 말소리가 없으면 Whisper 는 prompt 를
# 그대로 따라 적는다. 한 번 "Okay." 가 나오면 그 뒤 잡음마다 "Okay." 가
# 나와 아무 말도 없는데 자막이 계속 떴다 (잡음 8종 모두, turbo 실측).
segments, info = self._decode(audio, language, fast, "", vad=False)
duration = audio.size / SAMPLE_RATE
segments = [s for s in segments if _plausible(s, duration)]
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)
@@ -219,9 +251,16 @@ def _plausible(segment, duration_s: float) -> bool:
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

@@ -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 = [
("자막", "표시 설정"),
("용어집", "고유명사 고정"),
("설정", "세부 조정"),
("로그", "전체 기록 · 복사/저장"),
]
@@ -97,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)

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

@@ -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

@@ -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
@@ -152,9 +153,11 @@ class SileroDropsWhisper:
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, **_):
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)],
@@ -197,6 +200,28 @@ def test_repetition_without_vad_is_dropped():
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)

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

@@ -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"