echoact 0.1.0__py3-none-any.whl

echoact/ui/bridge.py

@@ -0,0 +1,50 @@
+"""Getting engine news onto the GUI thread.
+
+The job engine runs a job on its own thread and calls listeners from there.
+Qt widgets may only be touched from the thread that created them, so every
+event crosses here and nowhere else: this object is created on the main
+thread, so emitting one of its signals from a worker thread is a queued
+connection and Qt does the hand-off.
+
+Kept separate from the window so the rule has a name.  A listener that
+touched a widget directly would work most of the time, which is the worst
+possible failure mode for a threading bug.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+
+from ..jobs.engine import Event, EventKind, JobEngine
+
+
+class EngineBridge(QObject):
+    """Re-emits :class:`~echoact.jobs.engine.Event` as Qt signals."""
+
+    accepted = Signal(object)
+    state_changed = Signal(object)
+    segment_ready = Signal(object)
+    finished = Signal(object)
+    #: Anything at all, for a view that wants the raw stream.
+    any_event = Signal(object)
+
+    def __init__(self, engine: JobEngine, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self._engine = engine
+        self._off = engine.listen(self._on_event)
+
+    def _on_event(self, event: Event) -> None:
+        # Runs on the job thread.  Nothing below may touch a widget; these
+        # emits are queued because this object lives on the main thread.
+        self.any_event.emit(event)
+        if event.kind is EventKind.ACCEPTED:
+            self.accepted.emit(event)
+        elif event.kind is EventKind.STATE:
+            self.state_changed.emit(event)
+        elif event.kind is EventKind.SEGMENT:
+            self.segment_ready.emit(event)
+        elif event.kind is EventKind.FINISHED:
+            self.finished.emit(event)
+
+    def detach(self) -> None:
+        self._off()

echoact/ui/controls.py

@@ -0,0 +1,360 @@
+"""The controls around the reading surface.
+
+Two panels, both deliberately dumb: they show state and emit intent, and
+neither one calls the engine.  The window owns every decision, so there is
+one place where "can this be started right now?" is answered -- which is
+what N-09's "unavailable controls are disabled" needs to be true rather
+than mostly true.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QSizePolicy,
+    QSlider,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..domain import Gender, JobState, Language, SpeakingStyle, VoiceSettings
+from ..models.manifest import ModelEntry
+from ..policy import TEMPO_MAX, TEMPO_MIN
+from . import icons
+from .i18n import add_korean, duration, tr
+from .theme import METRICS, Palette
+
+add_korean(
+    {
+        "Reading": "읽기",
+        "While reading": "읽는 동안",
+        "Recent": "최근 항목",
+        "Ready": "준비됨",
+        "not prepared": "준비되지 않음",
+        "Open file": "파일 열기",
+        "Save audio": "오디오 저장",
+        "Save the part generated so far": "지금까지 생성된 부분 저장",
+    }
+)
+
+
+def label(text: str, role: str | None = None) -> QLabel:
+    lb = QLabel(text)
+    if role:
+        lb.setProperty("role", role)
+    return lb
+
+
+def separator() -> QFrame:
+    f = QFrame()
+    f.setProperty("role", "separator")
+    f.setFrameShape(QFrame.Shape.HLine)
+    f.setFixedHeight(1)
+    return f
+
+
+def tool_button(name: str, palette: Palette, *, size: int = 18) -> QToolButton:
+    """An icon button that always has an accessible name (N-30)."""
+    b = QToolButton()
+    b.setIcon(icons.icon(name, palette.text_secondary, palette.text_muted, size))
+    b.setIconSize(icons.icon_size(size))
+    text = tr(icons.accessible_name(name))
+    b.setToolTip(text)
+    b.setAccessibleName(text)
+    b.setAccessibleDescription(text)
+    b.setFixedSize(34, 34)
+    b.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+    return b
+
+
+class VoicePanel(QFrame):
+    """F-04 to F-08, F-83, F-30 -- everything the user picks before reading.
+
+    Emits :attr:`changed` with a complete :class:`VoiceSettings`, never a
+    partial edit, so the window never has to assemble one from widgets.
+    """
+
+    changed = Signal(object)  # VoiceSettings
+    autoplay_toggled = Signal(bool)
+    follow_toggled = Signal(bool)
+
+    def __init__(self, palette: Palette, entry: ModelEntry, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setObjectName("Panel")
+        self._palette = palette
+        self._entry = entry
+        self._muted = False  # guards against emitting while populating
+
+        m = METRICS
+        box = QVBoxLayout(self)
+        box.setContentsMargins(m.pad, m.pad, m.pad, m.pad)
+        box.setSpacing(m.gap)
+
+        box.addWidget(label(tr("Voice"), "section"))
+
+        self.language = QComboBox()
+        for lang, text in (
+            (Language.AUTO, tr("Automatic")),
+            (Language.KO, tr("Korean")),
+            (Language.EN, tr("English")),
+        ):
+            self.language.addItem(text, lang)
+        self._row(box, tr("Language"), self.language)
+
+        self.gender = QComboBox()
+        self.gender.addItem(tr("Female"), Gender.FEMALE)
+        self.gender.addItem(tr("Male"), Gender.MALE)
+        self._row(box, tr("Gender"), self.gender)
+
+        self.voice = QComboBox()
+        self._row(box, tr("Voice"), self.voice)
+
+        self.style = QComboBox()
+        for style, text in (
+            (SpeakingStyle.NATURAL, tr("Natural")),
+            (SpeakingStyle.CALM, tr("Calm")),
+            (SpeakingStyle.BRIGHT, tr("Bright")),
+            (SpeakingStyle.NARRATION, tr("Narration")),
+        ):
+            self.style.addItem(text, style)
+        self._row(box, tr("Style"), self.style)
+
+        # Tempo is a slider rather than a spin box: it is the one setting a
+        # user adjusts by ear, and a slider invites the small nudges that
+        # takes.  The value is shown beside it because F-07 fixes a range
+        # the user is entitled to see exactly.
+        tempo_row = QHBoxLayout()
+        tempo_row.setSpacing(m.gap)
+        tempo_row.addWidget(label(tr("Tempo"), "secondary"))
+        tempo_row.addStretch(1)
+        self.tempo_value = label("1.00x", "secondary")
+        tempo_row.addWidget(self.tempo_value)
+        box.addLayout(tempo_row)
+
+        self.tempo = QSlider(Qt.Orientation.Horizontal)
+        self.tempo.setRange(int(TEMPO_MIN * 100), int(TEMPO_MAX * 100))
+        self.tempo.setSingleStep(5)
+        self.tempo.setPageStep(10)
+        self.tempo.setValue(100)
+        self.tempo.setAccessibleName(tr("Tempo"))
+        box.addWidget(self.tempo)
+
+        box.addWidget(separator())
+        box.addWidget(label(tr("While reading"), "section"))
+
+        self.autoplay = QCheckBox(tr("Play as soon as ready"))
+        self.autoplay.setChecked(True)
+        box.addWidget(self.autoplay)
+
+        self.follow = QCheckBox(tr("Follow the reading position"))
+        self.follow.setChecked(True)
+        box.addWidget(self.follow)
+
+        box.addWidget(separator())
+        # F-22 and N-09: the budget in force is on the main screen, not
+        # only behind the settings button.
+        box.addWidget(label(tr("Resource budget"), "secondary"))
+        self.resources = label("", "muted")
+        self.resources.setWordWrap(True)
+        box.addWidget(self.resources)
+
+        self.setFixedWidth(272)
+        # Hugs its content: a card that stretches to the window height ends
+        # in a large empty panel, which reads as something missing.
+        self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Maximum)
+
+        self._populate_voices(Gender.FEMALE)
+        self.language.currentIndexChanged.connect(self._emit)
+        self.gender.currentIndexChanged.connect(self._on_gender)
+        self.voice.currentIndexChanged.connect(self._emit)
+        self.style.currentIndexChanged.connect(self._emit)
+        self.tempo.valueChanged.connect(self._on_tempo)
+        self.autoplay.toggled.connect(self.autoplay_toggled)
+        self.follow.toggled.connect(self.follow_toggled)
+
+    def _row(self, box: QVBoxLayout, name: str, widget: QWidget) -> None:
+        box.addWidget(label(name, "secondary"))
+        widget.setAccessibleName(name)
+        box.addWidget(widget)
+
+    def _populate_voices(self, gender: Gender) -> None:
+        was = self._muted
+        self._muted = True
+        self.voice.clear()
+        for v in self._entry.voices_for(gender):
+            self.voice.addItem(v.display_name, v.voice_id)
+            # F-53 puts the description in front of a person too, not only
+            # in the API answer.
+            self.voice.setItemData(self.voice.count() - 1, v.description, Qt.ItemDataRole.ToolTipRole)
+        self._muted = was
+
+    def _on_gender(self) -> None:
+        self._populate_voices(Gender(self.gender.currentData()))
+        self._emit()
+
+    def _on_tempo(self, value: int) -> None:
+        self.tempo_value.setText(f"{value / 100:.2f}x")
+        self._emit()
+
+    def _emit(self) -> None:
+        if self._muted:
+            return
+        self.changed.emit(self.settings())
+
+    def settings(self) -> VoiceSettings:
+        # Qt returns item data as a plain str even for a StrEnum, so the
+        # types are restored here rather than left to surprise a caller
+        # that asks for ``.value``.
+        return VoiceSettings(
+            model_id=self._entry.model_id,
+            language=Language(self.language.currentData()),
+            gender=Gender(self.gender.currentData()),
+            voice_id=self.voice.currentData() or self._entry.voices[0].voice_id,
+            style=SpeakingStyle(self.style.currentData()),
+            tempo=self.tempo.value() / 100,
+        )
+
+    def apply(self, settings: VoiceSettings, *, autoplay: bool, follow: bool) -> None:
+        """Show remembered settings without emitting a change (F-24)."""
+        self._muted = True
+        try:
+            self._select(self.language, settings.language)
+            self._select(self.gender, settings.gender)
+            self._populate_voices(settings.gender)
+            self._select(self.voice, settings.voice_id)
+            self._select(self.style, settings.style)
+            self.tempo.setValue(int(round(settings.tempo * 100)))
+            self.tempo_value.setText(f"{settings.tempo:.2f}x")
+            self.autoplay.setChecked(autoplay)
+            self.follow.setChecked(follow)
+        finally:
+            self._muted = False
+
+    @staticmethod
+    def _select(combo: QComboBox, value: object) -> None:
+        index = combo.findData(value)
+        if index >= 0:
+            combo.setCurrentIndex(index)
+
+    def set_resource_summary(self, text: str) -> None:
+        self.resources.setText(text)
+
+    def set_locked(self, locked: bool) -> None:
+        """F-10: an in-progress job's settings do not change.
+
+        The controls are disabled rather than merely ignored, because N-09
+        requires an unavailable control to look unavailable.
+        """
+        for w in (self.language, self.gender, self.voice, self.style, self.tempo):
+            w.setEnabled(not locked)
+
+
+class TransportBar(QWidget):
+    """F-12 to F-15: start, pause, stop, seek, and cancel.
+
+    The seek slider shows *playable* length, not the document's estimated
+    length: F-14 forbids seeking into audio that does not exist, and a
+    slider whose track runs past the end invites exactly that.
+    """
+
+    read_requested = Signal()
+    pause_requested = Signal()
+    stop_requested = Signal()
+    cancel_requested = Signal()
+    seek_requested = Signal(int)  # milliseconds
+
+    def __init__(self, palette: Palette, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._palette = palette
+        self._scrubbing = False
+        self._playable_ms = 0
+
+        m = METRICS
+        row = QHBoxLayout(self)
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(m.gap)
+
+        self.read = QPushButton("  " + tr("Read aloud"))
+        self.read.setProperty("variant", "primary")
+        self.read.setIcon(icons.icon("play", palette.text_on_accent))
+        self.read.setIconSize(icons.icon_size(16))
+        self.read.setAccessibleName(tr("Read aloud"))
+        self.read.setShortcut("Ctrl+Return")
+        self.read.setToolTip(tr("Read aloud") + "  (Ctrl+Enter)")
+        row.addWidget(self.read)
+
+        self.pause = tool_button("pause", palette)
+        self.stop = tool_button("stop", palette)
+        row.addWidget(self.pause)
+        row.addWidget(self.stop)
+
+        self.position = QSlider(Qt.Orientation.Horizontal)
+        self.position.setRange(0, 0)
+        self.position.setAccessibleName(tr("Playback position"))
+        self.position.setEnabled(False)
+        row.addWidget(self.position, 1)
+
+        self.time = label("0:00 / 0:00", "secondary")
+        self.time.setMinimumWidth(96)
+        self.time.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        row.addWidget(self.time)
+
+        self.read.clicked.connect(self.read_requested)
+        self.pause.clicked.connect(self.pause_requested)
+        self.stop.clicked.connect(self.stop_requested)
+        self.position.sliderPressed.connect(self._begin_scrub)
+        self.position.sliderReleased.connect(self._end_scrub)
+
+    def _begin_scrub(self) -> None:
+        self._scrubbing = True
+
+    def _end_scrub(self) -> None:
+        self._scrubbing = False
+        self.seek_requested.emit(self.position.value())
+
+    @property
+    def scrubbing(self) -> bool:
+        return self._scrubbing
+
+    def set_playable(self, ms: int) -> None:
+        self._playable_ms = ms
+        self.position.setEnabled(ms > 0)
+        if not self._scrubbing:
+            self.position.setRange(0, max(0, ms))
+
+    def set_position(self, ms: int) -> None:
+        if not self._scrubbing:
+            self.position.setValue(min(ms, self._playable_ms))
+        self.time.setText(f"{duration(ms)} / {duration(self._playable_ms)}")
+
+    def set_generating(self, generating: bool) -> None:
+        """The primary button is start or cancel, never both.
+
+        F-69 makes cancelling reachable in one place, and A.3 makes
+        cancelling the owner's way to reclaim the slot, so it belongs on
+        the button the eye already goes to.
+        """
+        if generating:
+            self.read.setText("  " + tr("Cancel generation"))
+            self.read.setIcon(icons.icon("close", self._palette.text_on_accent))
+            self.read.setAccessibleName(tr("Cancel generation"))
+        else:
+            self.read.setText("  " + tr("Read aloud"))
+            self.read.setIcon(icons.icon("play", self._palette.text_on_accent))
+            self.read.setAccessibleName(tr("Read aloud"))
+
+    def set_playback_state(self, state: JobState | str, *, playing: bool) -> None:
+        name = "pause" if playing else "play"
+        self.pause.setIcon(
+            icons.icon(name, self._palette.text_secondary, self._palette.text_muted, 18)
+        )
+        text = tr(icons.accessible_name(name))
+        self.pause.setToolTip(text)
+        self.pause.setAccessibleName(text)

echoact/ui/credential_dialog.py

@@ -0,0 +1,131 @@
+"""Showing a credential the one time it exists, per F-71.
+
+The app stores only a verifier, from which the credential cannot be
+recovered, so this dialog is the single moment the value is ever visible.
+Everything about it follows from that:
+
+* It says so, plainly, before the user closes it.  A dialog that looks
+  like every other confirmation invites the click that loses the value.
+* Copying is one button, because the alternative is a user retyping 44
+  random characters and blaming the app when it does not work.
+* The value is never logged and never written anywhere by this dialog.
+  N-17 keeps tokens out of logs and backups, and the clipboard is the
+  user's own choice rather than ours.
+
+A reissue is offered where it is needed rather than described: F-71 says
+a lost credential is reissued, and a user who has lost one is not in a
+position to read about it.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QApplication,
+    QDialog,
+    QDialogButtonBox,
+    QHBoxLayout,
+    QLabel,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from . import icons
+from .i18n import add_korean, tr
+from .theme import METRICS, Palette
+
+add_korean(
+    {
+        "Credential for {name}": "{name}의 자격 증명",
+        "This is the only time this value is shown.":
+            "이 값은 지금 한 번만 표시됩니다.",
+        "EchoAct keeps only a verifier, so it cannot show this again. "
+        "If it is lost, issue a new one for the same client.":
+            "에코액트는 검증 값만 저장하므로 이 값을 다시 표시할 수 없습니다. "
+            "잃어버린 경우 같은 클라이언트에 새로 발급하세요.",
+        "Copy": "복사",
+        "Copied": "복사됨",
+        "Done": "완료",
+        "Give this to the client, not to a person.":
+            "이 값은 사람이 아니라 클라이언트에 전달하세요.",
+    }
+)
+
+
+class CredentialDialog(QDialog):
+    """One credential, once."""
+
+    def __init__(self, issued, palette: Palette, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._token = issued.token
+        m = METRICS
+
+        self.setWindowTitle(
+            tr("Credential for {name}").format(name=issued.credential.name)
+        )
+        self.setModal(True)
+        self.setMinimumWidth(560)
+
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(m.pad_wide, m.pad_wide, m.pad_wide, m.pad_wide)
+        outer.setSpacing(m.gap_wide)
+
+        head = QHBoxLayout()
+        head.setSpacing(m.gap)
+        mark = QLabel()
+        mark.setPixmap(icons.pixmap("warning", palette.warn, 20, self.devicePixelRatioF()))
+        mark.setAlignment(Qt.AlignmentFlag.AlignTop)
+        head.addWidget(mark)
+        warning = QLabel(tr("This is the only time this value is shown."))
+        warning.setProperty("role", "section")
+        warning.setWordWrap(True)
+        head.addWidget(warning, 1)
+        outer.addLayout(head)
+
+        # Read-only rather than a label: a label cannot be selected with the
+        # keyboard, and N-30 wants the basic features usable without a mouse.
+        self.value = QPlainTextEdit(self._token)
+        self.value.setReadOnly(True)
+        self.value.setProperty("mono", True)
+        self.value.setFixedHeight(64)
+        self.value.setAccessibleName(tr("Credential"))
+        outer.addWidget(self.value)
+
+        explain = QLabel(
+            tr(
+                "EchoAct keeps only a verifier, so it cannot show this again. "
+                "If it is lost, issue a new one for the same client."
+            )
+        )
+        explain.setProperty("role", "muted")
+        explain.setWordWrap(True)
+        outer.addWidget(explain)
+
+        hint = QLabel(tr("Give this to the client, not to a person."))
+        hint.setProperty("role", "muted")
+        outer.addWidget(hint)
+
+        buttons = QDialogButtonBox()
+        self.copy_button = QPushButton("  " + tr("Copy"))
+        self.copy_button.setIcon(icons.icon("copy", palette.text_on_accent))
+        self.copy_button.setIconSize(icons.icon_size(16))
+        self.copy_button.setProperty("variant", "primary")
+        self.copy_button.clicked.connect(self._copy)
+        buttons.addButton(self.copy_button, QDialogButtonBox.ButtonRole.ActionRole)
+        done = buttons.addButton(tr("Done"), QDialogButtonBox.ButtonRole.AcceptRole)
+        done.setProperty("variant", "quiet")
+        buttons.accepted.connect(self.accept)
+        outer.addWidget(buttons)
+
+    def _copy(self) -> None:
+        clipboard = QApplication.clipboard()
+        if clipboard is not None:
+            clipboard.setText(self._token)
+        self.copy_button.setText("  " + tr("Copied"))
+
+
+def show_credential(parent: QWidget | None, issued, palette: Palette) -> None:
+    dialog = CredentialDialog(issued, palette, parent)
+    dialog.exec()

echoact/ui/fonts.py

@@ -0,0 +1,94 @@
+"""Loading the bundled typeface, when there is one.
+
+A.2 wants one bundled Korean and Latin family rather than the per-OS
+defaults, so that metrics -- and therefore N-12's synchronisation
+measurements and N-30's layout checks -- are identical on Windows and
+macOS.  Without it the app still looks right, but a measurement taken on
+one machine does not transfer to another, because Malgun Gothic and Apple
+SD Gothic Neo do not lay out the same text the same way.
+
+The font is not committed to the repository.  It is fetched by
+``scripts/fetch_fonts.py`` into ``echoact/assets/fonts`` and picked up
+here if it is present; the packaging step includes whatever it finds.
+Two reasons for that split: a licence that requires its own notice file
+should be acquired deliberately rather than inherited by a checkout, and
+a few megabytes of binary in a source tree is a cost every clone pays
+forever.
+
+``load()`` is safe to call when nothing is there.  A missing font is a
+measurement caveat, not a failure -- so it degrades to the per-OS stack
+and says so, rather than refusing to start.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..util.logging import get_logger
+
+log = get_logger("ui.fonts")
+
+ASSET_DIR = Path(__file__).resolve().parent.parent / "assets" / "fonts"
+
+#: The family A.2 calls for.  SIL Open Font License, covers Hangul and
+#: Latin in one family with matching metrics, and has a variable weight
+#: axis -- which matters because N-13's alternative mechanism was "a
+#: variable font whose weight axis preserves metrics".
+BUNDLED_FAMILY = "Pretendard"
+
+
+@dataclass(frozen=True, slots=True)
+class FontReport:
+    """What was loaded, for F-72's diagnostic export and for a test.
+
+    ``metrics_are_portable`` is the fact that actually matters: it says
+    whether a layout measurement taken here would mean anything on
+    another machine.
+    """
+
+    families: tuple[str, ...]
+    files: tuple[str, ...]
+    bundled_available: bool
+
+    @property
+    def metrics_are_portable(self) -> bool:
+        return self.bundled_available
+
+
+def available_files() -> tuple[Path, ...]:
+    if not ASSET_DIR.is_dir():
+        return ()
+    return tuple(
+        sorted(p for p in ASSET_DIR.iterdir() if p.suffix.lower() in {".ttf", ".otf", ".ttc"})
+    )
+
+
+def load() -> FontReport:
+    """Register every bundled face with Qt.  Returns what is now usable."""
+    from PySide6.QtGui import QFontDatabase
+
+    families: list[str] = []
+    files: list[str] = []
+    for path in available_files():
+        font_id = QFontDatabase.addApplicationFont(str(path))
+        if font_id < 0:
+            log.warning("could not load bundled font %s", path.name)
+            continue
+        files.append(path.name)
+        families.extend(QFontDatabase.applicationFontFamilies(font_id))
+
+    unique = tuple(dict.fromkeys(families))
+    report = FontReport(
+        families=unique,
+        files=tuple(files),
+        bundled_available=any(BUNDLED_FAMILY in f for f in unique),
+    )
+    if not report.bundled_available:
+        # Said once, at start-up, because it changes what a measurement
+        # means rather than what the user sees.
+        log.info(
+            "no bundled typeface; using the per-OS stack, so layout "
+            "measurements are not comparable across operating systems"
+        )
+    return report