aa-tui 0.1.0__tar.gz

aa_tui-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.3
+Name: aa-tui
+Version: 0.1.0
+Summary: Add your description here
+Author: Maxwell Ludden
+Author-email: Maxwell Ludden <maxludden@me.com>
+Requires-Dist: aa-meta
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: mutagen>=1.48.1
+Requires-Dist: pypdf>=6.20.0
+Requires-Dist: rich>=15.0.0
+Requires-Dist: textual>=8.2.8
+Requires-Dist: typer>=0.27.3
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# aa-tui
+
+Textual front-end for [aa-meta](../aa-meta): search Anna's Archive, inspect a result, download it, and edit its metadata.
+
+```bash
+uv sync
+uv run aa-tui ["query"] [--base-url ...] [--cookie ...] [-o DIR]
+```
+
+Results are shown with `aa-meta`'s columns: #, Ext, Title, Author (colour-coded per author), Size, Lang, Year and MD5.
+
+Keys: `Enter` in the search box searches (a spinner popup shows while waiting; `esc` cancels); `/` focuses search; `↑/↓` selects (details load automatically); `Enter` or a click on a row opens a details popup (`e`/`d` work inside it, `esc` closes); `o` opens the current search on the site in your browser; `d` downloads (needs `AA_SECRET_KEY` or 1Password); `q` quits (when not typing).
+
+## Editing metadata
+
+`e` opens a form for the highlighted book (title, author, publisher, series, year, language, ISBN, description). `ctrl+s` saves, `esc` cancels.
+Edits are stored per MD5 in `~/.config/aa-tui/metadata.json` and shown in the detail pane. When the book has been downloaded, saving also embeds the tags in the file; otherwise they are embedded as soon as it downloads. `w` re-embeds on demand.
+
+Supported formats: EPUB (OPF Dublin Core + calibre series), PDF (info dictionary), M4B/M4A/MP4 (iTunes atoms), MP3 (ID3v2). Other formats are left untouched with an error notice.
+
+## Errors and output
+
+Nothing is printed over the TUI. Anything written to stdout/stderr or logged through `loguru` (including from `aa-meta`) appears as a toast: info for stdout and `INFO`, warning for `WARNING`, error (shown longer) for stderr and `ERROR`+. Expected failures (blocked search, API refusals, network errors, unsupported tag formats) are toasts too. An unexpected exception opens a modal with the full traceback instead of quitting; `esc` closes it.

aa_tui-0.1.0/README.md

@@ -0,0 +1,23 @@
+# aa-tui
+
+Textual front-end for [aa-meta](../aa-meta): search Anna's Archive, inspect a result, download it, and edit its metadata.
+
+```bash
+uv sync
+uv run aa-tui ["query"] [--base-url ...] [--cookie ...] [-o DIR]
+```
+
+Results are shown with `aa-meta`'s columns: #, Ext, Title, Author (colour-coded per author), Size, Lang, Year and MD5.
+
+Keys: `Enter` in the search box searches (a spinner popup shows while waiting; `esc` cancels); `/` focuses search; `↑/↓` selects (details load automatically); `Enter` or a click on a row opens a details popup (`e`/`d` work inside it, `esc` closes); `o` opens the current search on the site in your browser; `d` downloads (needs `AA_SECRET_KEY` or 1Password); `q` quits (when not typing).
+
+## Editing metadata
+
+`e` opens a form for the highlighted book (title, author, publisher, series, year, language, ISBN, description). `ctrl+s` saves, `esc` cancels.
+Edits are stored per MD5 in `~/.config/aa-tui/metadata.json` and shown in the detail pane. When the book has been downloaded, saving also embeds the tags in the file; otherwise they are embedded as soon as it downloads. `w` re-embeds on demand.
+
+Supported formats: EPUB (OPF Dublin Core + calibre series), PDF (info dictionary), M4B/M4A/MP4 (iTunes atoms), MP3 (ID3v2). Other formats are left untouched with an error notice.
+
+## Errors and output
+
+Nothing is printed over the TUI. Anything written to stdout/stderr or logged through `loguru` (including from `aa-meta`) appears as a toast: info for stdout and `INFO`, warning for `WARNING`, error (shown longer) for stderr and `ERROR`+. Expected failures (blocked search, API refusals, network errors, unsupported tag formats) are toasts too. An unexpected exception opens a modal with the full traceback instead of quitting; `esc` closes it.

aa_tui-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "aa-tui"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "aa-meta",
+    "httpx>=0.28.1",
+    "loguru>=0.7.3",
+    "mutagen>=1.48.1",
+    "pypdf>=6.20.0",
+    "rich>=15.0.0",
+    "textual>=8.2.8",
+    "typer>=0.27.3",
+]
+
+[[project.authors]]
+name = "Maxwell Ludden"
+email = "maxludden@me.com"
+
+[project.scripts]
+aa-tui = "aa_tui.cli:app"
+
+[build-system]
+requires = ["uv_build>=0.13.0,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.sources.aa-meta]
+path = "../aa-meta"
+editable = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "aa_tui.tags"
+disallow_untyped_calls = false
+
+[dependency-groups]
+dev = [
+    "mypy>=2.4.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "ruff>=0.17.0",
+]

aa_tui-0.1.0/pyproject.toml.orig

@@ -0,0 +1,48 @@
+[project]
+name = "aa-tui"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Maxwell Ludden", email = "maxludden@me.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "aa-meta",
+    "httpx>=0.28.1",
+    "loguru>=0.7.3",
+    "mutagen>=1.48.1",
+    "pypdf>=6.20.0",
+    "rich>=15.0.0",
+    "textual>=8.2.8",
+    "typer>=0.27.3",
+]
+
+[project.scripts]
+aa-tui = "aa_tui.cli:app"
+
+[build-system]
+requires = ["uv_build>=0.13.0,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.sources]
+aa-meta = { path = "../aa-meta", editable = true }
+
+[dependency-groups]
+dev = [
+    "mypy>=2.4.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "ruff>=0.17.0",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "aa_tui.tags"  # mutagen is untyped
+disallow_untyped_calls = false

aa_tui-0.1.0/src/aa_tui/__init__.py

@@ -0,0 +1 @@
+"""Textual front-end for aa-meta."""

aa_tui-0.1.0/src/aa_tui/app.py

@@ -0,0 +1,422 @@
+"""The Textual application: search box, results table, and detail pane."""
+
+from __future__ import annotations
+
+import sys
+import threading
+import webbrowser
+from dataclasses import replace
+from pathlib import Path
+from typing import Any, ClassVar
+from urllib.parse import urlencode
+
+from aa_meta.authors import format_authors
+from aa_meta.cli import format_ext, format_size
+from aa_meta.config import Settings
+from aa_meta.models import BookRecord
+from aa_meta.search import Book
+from loguru import logger
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Horizontal
+from textual.widgets import DataTable, Footer, Header, Input, Static
+from textual.worker import get_current_worker
+
+from . import service
+from .capture import ToastStream
+from .details_screen import DetailsScreen
+from .edit_screen import EditScreen
+from .error_screen import ErrorScreen
+from .loading_screen import LoadingScreen
+from .metadata import DEFAULT_STORE, EditableMeta, MetadataStore
+from .tags import TagError, write_tags
+
+# (label, width) of each results column; the MD5 stays last and full-width.
+COLUMNS: tuple[tuple[str, int | None], ...] = (
+    ("#", 3),
+    ("Ext", 6),
+    ("Title", 44),
+    ("Author", 26),
+    ("Size", 9),
+    ("Lang", 5),
+    ("Year", 5),
+    ("MD5", 32),
+)
+
+
+def _plain(value: str) -> Text:
+    """Return ``value`` in light grey, or a dim dash when empty."""
+    return Text(value, style="#C2C2C2") if value else Text("-", style="dim")
+
+
+def result_rows(books: list[Book]) -> list[tuple[Text | str, ...]]:
+    """Build one table row per book, splitting the parsed record into columns.
+
+    Books without a parsed record (bare links) fall back to their raw ``meta``
+    text in the Author column and dashes elsewhere.
+    """
+    authors = format_authors([b.record.author if b.record else b.meta for b in books])
+    rows: list[tuple[Text | str, ...]] = []
+    for i, (book, author) in enumerate(zip(books, authors, strict=True), 1):
+        rec = book.record
+        rows.append(
+            (
+                Text(str(i), style="dim italic"),
+                format_ext(rec.extension if rec else None),
+                Text(book.title, style="bold"),
+                author,
+                format_size(rec.size_text if rec else None),
+                _plain(rec.language if rec else ""),
+                _plain(str(rec.year) if rec and rec.year else ""),
+                Text(book.md5, style="#00ccff"),
+            )
+        )
+    return rows
+
+
+def apply_meta(rec: BookRecord, meta: EditableMeta) -> BookRecord:
+    """Return ``rec`` with its editable fields replaced by ``meta``."""
+    year = int(meta.year) if meta.year.isdigit() else None
+    identifiers = rec.identifiers
+    if meta.isbn != (rec.isbns[0] if rec.isbns else ""):
+        # ``isbns`` derives from the identifiers, so an edited ISBN replaces both.
+        identifiers = {k: v for k, v in rec.identifiers.items() if k[:4] != "isbn"}
+        if meta.isbn:
+            identifiers["isbn13"] = (meta.isbn,)
+    return replace(
+        rec,
+        title=meta.title,
+        author=meta.author,
+        publisher=meta.publisher,
+        series=meta.series,
+        series_index=meta.series_index,
+        year=year,
+        languages=(meta.language,) if meta.language else (),
+        identifiers=identifiers,
+        description=meta.description,
+    )
+
+
+def render_record(rec: BookRecord, *, edited: bool = False) -> Text:
+    """Format ``rec`` as styled text for the detail pane."""
+    text = Text()
+    if edited:
+        text.append("✎ edited locally\n", style="yellow")
+    text.append(f"{rec.title or rec.md5}\n", style="bold")
+    series = f"{rec.series} #{rec.series_index}" if rec.series_index else rec.series
+    fields = [
+        ("Author", rec.author),
+        ("Publisher", rec.publisher),
+        ("Series", series),
+        ("Year", str(rec.year) if rec.year else ""),
+        ("Language", ", ".join(rec.languages)),
+        ("Format", f"{rec.extension} {rec.size_text}".strip()),
+        ("ISBN", ", ".join(rec.isbns)),
+    ]
+    for label, value in fields:
+        if value:
+            text.append(f"{label}: ", style="cyan")
+            text.append(f"{value}\n")
+    if rec.description:
+        text.append(f"\n{rec.description}")
+    return text
+
+
+class AaApp(App[None]):
+    """Search Anna's Archive, inspect a result, and download it."""
+
+    CSS = """
+    #main { height: 1fr; }
+    DataTable { width: 2fr; height: 100%; }
+    #detail { width: 1fr; height: 100%; border-left: solid $primary; padding: 0 1;
+              overflow-y: auto; }
+    """
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("/", "focus_search", "Search"),
+        Binding("d", "download", "Download"),
+        Binding("o", "open_browser", "Open in browser"),
+        Binding("e", "edit", "Edit metadata"),
+        Binding("w", "write_tags", "Write tags"),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def __init__(
+        self,
+        settings: Settings,
+        query: str | None = None,
+        store: MetadataStore | None = None,
+    ) -> None:
+        """Create the app with resolved ``settings``, a first query and edit store."""
+        super().__init__()
+        self._settings = settings
+        self._initial_query = query
+        self._store = store or MetadataStore(DEFAULT_STORE)
+        self._records: dict[str, BookRecord] = {}
+        self._last_query = ""
+        self._loading: LoadingScreen | None = None
+
+    def compose(self) -> ComposeResult:
+        """Lay out the widgets."""
+        yield Header()
+        yield Input(placeholder="Search Anna's Archive…", id="query")
+        with Horizontal(id="main"):
+            yield DataTable(id="results", cursor_type="row")
+            yield Static("Select a result to see its details.", id="detail")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Route stray output to toasts, prepare the table and run any first query."""
+        self._capture_output()
+        table = self.query_one(DataTable)
+        for label, width in COLUMNS:
+            table.add_column(label, width=width)
+        if self._initial_query:
+            self.query_one(Input).value = self._initial_query
+            self._last_query = self._initial_query
+            self._search(self._initial_query)
+
+    def _capture_output(self) -> None:
+        """Send stdout, stderr and loguru output to toasts instead of the screen."""
+        self._saved_streams = (sys.stdout, sys.stderr)
+        self._out = ToastStream(self.toast, "information")
+        self._err = ToastStream(self.toast, "error")
+        sys.stdout, sys.stderr = self._out, self._err
+        logger.remove()
+        self._log_id = logger.add(self._log_sink, level="INFO", format="{message}")
+
+    def on_unmount(self) -> None:
+        """Restore the real streams and flush any partial line."""
+        self._out.flush_partial()
+        self._err.flush_partial()
+        sys.stdout, sys.stderr = self._saved_streams
+        logger.remove(self._log_id)
+
+    def _log_sink(self, message: Any) -> None:
+        """Show a loguru record as a toast at the matching severity."""
+        level = message.record["level"].no
+        severity = (
+            "error" if level >= 40 else "warning" if level >= 30 else "information"
+        )
+        self.toast(message.record["message"], severity)
+
+    def toast(self, message: str, severity: str = "information") -> None:
+        """Show a toast from any thread (errors linger longer)."""
+        timeout = 10.0 if severity == "error" else 5.0
+        if self._thread_id == threading.get_ident():
+            self.notify(message, severity=severity, timeout=timeout)  # type: ignore[arg-type]
+        else:
+            self.call_from_thread(
+                self.notify, message, severity=severity, timeout=timeout
+            )
+
+    def _handle_exception(self, error: Exception) -> None:
+        """Show unexpected exceptions in a modal instead of exiting the app.
+
+        Overrides Textual's private hook, which would otherwise print the
+        traceback and quit. A failed background worker leaves the app fully
+        usable; an exception in a UI handler may leave that widget unresponsive,
+        so the modal says to restart if the app stops reacting.
+        """
+        from textual.worker import WorkerFailed
+
+        recoverable = isinstance(error, WorkerFailed)
+        cause = error.error if isinstance(error, WorkerFailed) else error
+        self._end_loading()
+        self.push_screen(ErrorScreen(cause, recoverable=recoverable))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Search for the submitted text; ignore blank input."""
+        if query := event.value.strip():
+            self._last_query = query
+            self._search(query)
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """Load details for the highlighted row."""
+        if event.row_key.value:
+            self._load_details(event.row_key.value)
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Pop up the full details for a clicked (or Enter-ed) row."""
+        md5 = event.row_key.value
+        if md5 is None:
+            return
+        if md5 not in self._records:
+            self.notify("Details are still loading…")
+            return
+        rec = self._records[md5]
+        edited = self._store_has_edits(md5)
+        if edited and (entry := self._store.get(md5)):
+            rec = apply_meta(rec, entry.meta)
+        self.push_screen(DetailsScreen(rec, edited=edited))
+
+    def action_open_browser(self) -> None:
+        """Open the current search's results page on the site in the browser."""
+        if not self._last_query:
+            self.notify("Run a search first.", severity="warning")
+            return
+        url = f"{self._settings.origin}/search?{urlencode({'q': self._last_query})}"
+        if not webbrowser.open(url):
+            self.notify(f"Could not open a browser. URL: {url}", severity="error")
+
+    def action_focus_search(self) -> None:
+        """Move focus to the search box."""
+        self.query_one(Input).focus()
+
+    def _highlighted_md5(self) -> str | None:
+        """MD5 of the highlighted row, or ``None`` when the table is empty."""
+        table = self.query_one(DataTable)
+        if not table.row_count:
+            return None
+        return table.coordinate_to_cell_key(table.cursor_coordinate).row_key.value
+
+    def action_download(self) -> None:
+        """Download the highlighted book."""
+        if md5 := self._highlighted_md5():
+            self._download(md5)
+
+    def action_edit(self) -> None:
+        """Open the metadata form for the highlighted book."""
+        md5 = self._highlighted_md5()
+        rec = self._records.get(md5 or "")
+        if md5 is None or rec is None:
+            self.notify("Wait for the details to load first.", severity="warning")
+            return
+        entry = self._store.get(md5)
+        meta = entry.meta if entry else EditableMeta.from_record(rec)
+
+        def done(new: EditableMeta | None) -> None:
+            if new is None:
+                return
+            entry = self._store.set_meta(md5, new)
+            self._show_record(md5)
+            if entry.file and entry.file.exists():
+                self._embed(entry.file, entry.meta)
+            else:
+                self.notify(
+                    "Saved. Tags are written when the file is downloaded (or press w)."
+                )
+
+        self.push_screen(EditScreen(meta), done)
+
+    def action_write_tags(self) -> None:
+        """Embed the stored metadata into the downloaded file."""
+        md5 = self._highlighted_md5()
+        entry = self._store.get(md5) if md5 else None
+        if entry is None or entry.file is None or not entry.file.exists():
+            self.notify(
+                "Edit metadata and download the file first.", severity="warning"
+            )
+            return
+        self._embed(entry.file, entry.meta)
+
+    def _embed(self, path: Path, meta: EditableMeta) -> None:
+        """Write ``meta`` into ``path`` and notify the outcome."""
+        try:
+            write_tags(path, meta)
+        except TagError as exc:
+            self.notify(str(exc), severity="error")
+        else:
+            self.notify(f"Tagged {path.name}")
+
+    def _show_record(self, md5: str) -> None:
+        """Render the record for ``md5`` with any local edits applied."""
+        rec = self._records[md5]
+        edited = self._store_has_edits(md5)
+        if edited and (entry := self._store.get(md5)):
+            rec = apply_meta(rec, entry.meta)
+        self.query_one("#detail", Static).update(render_record(rec, edited=edited))
+
+    def _search(self, query: str) -> None:
+        """Show the loading modal and start the search worker."""
+        self._loading = LoadingScreen(query)
+        self.push_screen(self._loading, self._on_loading_closed)
+        self._run_search(query)
+
+    def _on_loading_closed(self, cancelled: bool | None) -> None:
+        """Abandon the in-flight search if the user pressed ``esc``."""
+        self._loading = None
+        if cancelled:
+            self.workers.cancel_group(self, "search")
+
+    def _end_loading(self) -> None:
+        """Close the loading modal if it is still showing."""
+        if self._loading is not None:
+            loading, self._loading = self._loading, None
+            loading.dismiss(False)
+
+    @work(thread=True, exclusive=True, group="search")
+    def _run_search(self, query: str) -> None:
+        """Run a search off the UI thread and show the results or the error."""
+        worker = get_current_worker()
+        try:
+            books = service.search(self._settings, query)
+        except service.SERVICE_ERRORS as exc:
+            if not worker.is_cancelled:
+                self.call_from_thread(self._search_failed, str(exc))
+            return
+        if not worker.is_cancelled:
+            self.call_from_thread(self._show_results, books)
+
+    def _search_failed(self, message: str) -> None:
+        """Close the loading modal and report ``message``."""
+        self._end_loading()
+        self.notify(message, severity="error")
+
+    def _show_results(self, books: list[Book]) -> None:
+        """Replace the table rows with ``books`` and focus the table."""
+        self._end_loading()
+        table = self.query_one(DataTable)
+        table.clear()
+        for book, row in zip(books, result_rows(books), strict=True):
+            table.add_row(*row, key=book.md5)
+        if books:
+            table.focus()
+        else:
+            self.notify("No results.")
+
+    @work(thread=True, exclusive=True, group="details")
+    def _load_details(self, md5: str) -> None:
+        """Fetch a record off the UI thread and render it unless superseded."""
+        worker = get_current_worker()
+        try:
+            rec = service.details(self._settings, md5)
+        except service.SERVICE_ERRORS as exc:
+            if not worker.is_cancelled:
+                self.call_from_thread(self.notify, str(exc), severity="error")
+            return
+        if not worker.is_cancelled:
+            self.call_from_thread(self._remember, rec)
+
+    def _remember(self, rec: BookRecord) -> None:
+        """Cache ``rec`` and show it unless the cursor has moved on."""
+        self._records[rec.md5] = rec
+        if self._highlighted_md5() == rec.md5:
+            self._show_record(rec.md5)
+
+    @work(thread=True, group="download")
+    def _download(self, md5: str) -> None:
+        """Download ``md5`` off the UI thread and report the outcome."""
+        self.call_from_thread(self.notify, f"Downloading {md5}…")
+        try:
+            path = service.download(self._settings, md5, f"{md5}.bin")
+        except service.SERVICE_ERRORS as exc:
+            self.call_from_thread(self.notify, str(exc), severity="error")
+            return
+        self.call_from_thread(self._downloaded, md5, path)
+
+    def _downloaded(self, md5: str, path: Path) -> None:
+        """Record the saved ``path`` and embed any stored edits into it."""
+        rec = self._records.get(md5)
+        seed = EditableMeta.from_record(rec) if rec else EditableMeta()
+        entry = self._store.set_file(md5, path, seed)
+        self.notify(f"Saved {path}")
+        if self._store_has_edits(md5):
+            self._embed(path, entry.meta)
+
+    def _store_has_edits(self, md5: str) -> bool:
+        """Whether the user edited ``md5`` (as opposed to just recording a path)."""
+        rec = self._records.get(md5)
+        entry = self._store.get(md5)
+        return bool(entry and rec and entry.meta != EditableMeta.from_record(rec))

aa_tui-0.1.0/src/aa_tui/capture.py

@@ -0,0 +1,47 @@
+"""Turn writes to stdout/stderr and loguru messages into app toasts."""
+
+from __future__ import annotations
+
+import io
+from collections.abc import Callable
+
+from rich.text import Text
+
+Severity = str  # a Textual notify severity: "information", "warning" or "error"
+Emit = Callable[[str, Severity], None]
+
+
+class ToastStream(io.TextIOBase):
+    """A text stream that emits each completed non-blank line to ``emit``.
+
+    ANSI colour codes (from Rich, loguru, ...) are stripped. A trailing partial
+    line is emitted by :meth:`flush_partial`, which the app calls on shutdown.
+    """
+
+    def __init__(self, emit: Emit, severity: Severity) -> None:
+        """Send lines to ``emit`` with the given ``severity``."""
+        self._emit = emit
+        self._severity = severity
+        self._buffer = ""
+
+    def writable(self) -> bool:
+        """This stream accepts writes."""
+        return True
+
+    def write(self, s: str) -> int:
+        """Buffer ``s`` and emit every complete line in it."""
+        self._buffer += s
+        *lines, self._buffer = self._buffer.split("\n")
+        for line in lines:
+            self._send(line)
+        return len(s)
+
+    def flush_partial(self) -> None:
+        """Emit whatever is left in the buffer."""
+        rest, self._buffer = self._buffer, ""
+        self._send(rest)
+
+    def _send(self, line: str) -> None:
+        """Emit ``line`` if it has visible content."""
+        if text := Text.from_ansi(line).plain.strip():
+            self._emit(text, self._severity)

aa_tui-0.1.0/src/aa_tui/cli.py

@@ -0,0 +1,37 @@
+"""Typer entry point: ``aa-tui [QUERY]``."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from aa_meta.config import DEFAULT_BASE_URL, Settings
+from aa_meta.cookies import read_cookie_file
+
+from .app import AaApp
+
+DEFAULT_OUTPUT_DIR = Path.home() / "Downloads"
+
+app = typer.Typer(help="Terminal UI for searching and downloading from Anna's Archive.")
+
+
+@app.command()
+def main(
+    query: Annotated[str | None, typer.Argument(help="Search to run on start.")] = None,
+    base_url: Annotated[
+        str, typer.Option("--base-url", envvar="AA_BASE_URL", help="Mirror domain.")
+    ] = DEFAULT_BASE_URL,
+    cookie: Annotated[
+        str | None,
+        typer.Option("--cookie", envvar="AA_COOKIE", help="Browser Cookie header."),
+    ] = None,
+    output: Annotated[
+        Path, typer.Option("--output", "-o", help="Download directory.")
+    ] = DEFAULT_OUTPUT_DIR,
+) -> None:
+    """Launch the TUI, optionally running QUERY immediately."""
+    settings = Settings(
+        base_url=base_url, cookie=cookie or read_cookie_file(), download_dir=output
+    )
+    AaApp(settings, query).run()