Automated sync from GitHub

.env.example

@@ -15,7 +15,8 @@ DATABASE_URL=postgresql://user:password@host/dbname?sslmode=require
 ADMIN_IDS=
 # Numeric chat id of a channel/group where the bot posts start-up, job and error notices.
 LOG_CHANNEL=
-# The banner shown on /start is set with the owner's /smedia command.
+# Banner for /start: an https image URL or a file path.
+START_IMAGE=
 # Optional Telethon StringSession to log in with (otherwise stored in the database).
 SESSION_STRING=
 

.gitattributes

@@ -1,8 +1,8 @@
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
 *.otf filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -2,23 +2,9 @@ FROM python:3.12-slim
 
 # ffmpeg/ffprobe: metadata + track keep/reorder (stream copy, no re-encoding)
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends ffmpeg ca-certificates curl \
+    && apt-get install -y --no-install-recommends ffmpeg ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
-# Ookla speedtest CLI: /speed needs it. The version is pinned so a rebuild
-# cannot silently change the tool. The tarball unpacks to a binary called
-# "speedtest"; it is installed as "ookla-speedtest" to match the bot.
-RUN set -eux; \
-    case "$(uname -m)" in \
-        x86_64) arch=x86_64 ;; \
-        aarch64|arm64) arch=aarch64 ;; \
-        *) echo "unsupported architecture: $(uname -m)" >&2; exit 1 ;; \
-    esac; \
-    curl -fsSL --retry 3 "https://install.speedtest.net/app/cli/ookla-speedtest-1.2.0-linux-${arch}.tgz" -o /tmp/ookla.tgz; \
-    tar -xzf /tmp/ookla.tgz -C /tmp; \
-    install -m 0755 /tmp/speedtest /usr/local/bin/ookla-speedtest; \
-    rm -rf /tmp/ookla.tgz /tmp/speedtest
-
 # Hugging Face Spaces run Docker containers as user 1000
 RUN useradd -m -u 1000 user
 USER user

bot/app.py

@@ -17,16 +17,13 @@ import telethon
 from telethon import errors, events, functions, types
 
 from . import fasttransfer as transfer
-from . import media, panels, sysinfo, telegraph
+from . import media, panels, sysinfo
 from .config import Config
-from .db import MAX_FORMATS, Database
-from .formats import apply_format_field, resolve_format, resolve_thumbnail
-from .parser import compute_new_name, effective_info, missing_variables, parse_info, split_ext
+from .db import Database
+from .parser import build_manual_name, compute_new_name, missing_variables
 from .pipeline import Renamer, original_name_of, source_ext
 from .queue import Job, JobQueue
-from .sequence import detect_episodes, format_report, plan_sort
 from .settings_ops import META_COMMANDS, apply_setting, parse_channel, preview_template
-from .speedtest import format_speed, run_speedtest
 from .utils import clip, esc, human_size
 
 log = logging.getLogger(__name__)
@@ -34,16 +31,7 @@ log = logging.getLogger(__name__)
 COMMANDS = [
     ("start", "Open the main menu"),
     ("help", "How to use the bot"),
-    ("rename", "Pick a saved format and rename a file"),
-    ("formats", "Manage your saved rename formats"),
-    ("sequence", "Collect files to sort by episode"),
-    ("sort", "Sort the collected files and send them back"),
-    ("check", "See what the bot reads from a file"),
-    ("ethumb", "Extract a thumbnail from a video"),
-    ("resize", "Resize an image (reply to it)"),
-    ("speed", "Check the bot's internet speed"),
-    ("mediainfo", "Full media info of a file, published to telegra.ph"),
-    ("smedia", "Set the start image or GIF (owner only)"),
+    ("rename", "Reply to a file with a new name"),
     ("mode", "Choose Filename or Caption mode"),
     ("template", "Set the filename template"),
     ("caption", "Set the caption template"),
@@ -59,18 +47,17 @@ COMMANDS = [
     ("status", "Show basic bot uptime, ping, and version information."),
     ("stats", "Show detailed system stats such as users, CPU, RAM, and disk usage."),
 ]
-OWNER_COMMANDS = {"addadmin", "deladmin", "admins", "smedia"}
+OWNER_COMMANDS = {"addadmin", "deladmin", "admins"}
 BACK = {
     "template": "rename", "remove": "rename", "caption": "cap",
     "mt_title": "meta", "mt_author": "meta", "mt_artist": "meta",
     "mt_audio": "meta", "mt_subtitle": "meta", "mt_video": "meta",
     "keep_audio": "tool", "keep_subtitle": "tool",
 }
-PANEL_NAMES = {"home", "rename", "cap", "meta", "tool", "ftype", "help", "admin", "formats"}
+PANEL_NAMES = {"home", "rename", "cap", "meta", "tool", "ftype", "help", "admin"}
 QUEUE_SETTLE = 1.5  # seconds an idle worker waits so files sent together are queued in message order
 TRACKS_PROBE_BYTES = 12 * 1024 * 1024
 TRACKS_FULL_LIMIT = 700 * 1024 * 1024
-COPY_DELAY = 0.4  # a short pause so Telegram keeps the copies in order
 
 
 @dataclass
@@ -81,7 +68,6 @@ class Pending:
     back: str
     is_photo: bool
     expires: float
-    format_id: Optional[int] = None
 
 
 def cmd_pattern(name: str) -> "re.Pattern[str]":
@@ -103,14 +89,6 @@ def is_renameable(message: Any) -> bool:
     )
 
 
-def is_image(message: Any) -> bool:
-    """A photo, or a document with an image mime type."""
-    if getattr(message, "photo", None) is not None:
-        return True
-    mime = getattr(getattr(message, "file", None), "mime_type", "") or ""
-    return mime.startswith("image/")
-
-
 class App:
     PENDING_TTL = 300
 
@@ -123,9 +101,6 @@ class App:
         self.renamer = Renamer(client, cfg, db, self._log_send)
         self.queue = JobQueue(self.renamer.process, workers=cfg.max_jobs, on_cancelled=self._on_job_cancelled, settle=QUEUE_SETTLE)
         self._warned: Set[int] = set()
-        self._seq_status: Dict[int, Any] = {}
-        self._ethumbs: Dict[int, bytes] = {}
-        self._resize_source: Dict[int, bytes] = {}
 
     # ------------------------------------------------------------------ auth
     def is_owner(self, uid: Optional[int]) -> bool:
@@ -220,7 +195,6 @@ class App:
             )
         add(self._guard(self.on_media), events.NewMessage(incoming=True, func=lambda e: e.is_private and is_renameable(e.message)))
         add(self._guard(self.on_photo), events.NewMessage(incoming=True, func=lambda e: e.is_private and e.message.photo is not None))
-        add(self._guard(self.on_animation), events.NewMessage(incoming=True, func=lambda e: e.is_private and e.message.gif is not None))
         add(self._guard(self.on_text), events.NewMessage(incoming=True, func=self._wants_text))
         add(self._guard(self.on_callback), events.CallbackQuery())
         add(self._on_stranger, events.NewMessage(incoming=True, func=lambda e: e.is_private and not self.is_allowed(e.sender_id)))
@@ -241,12 +215,6 @@ class App:
             "tracks": self.cmd_tracks, "thumb": self.cmd_thumb, "delthumb": self.cmd_delthumb,
             "removewords": self.cmd_remove, "setchannel": self.cmd_setchannel, "queue": self.cmd_queue,
             "cancel": self.cmd_cancel, "status": self.cmd_status, "stats": self.cmd_stats,
-            "formats": self.cmd_formats,
-            "sequence": self.cmd_sequence, "sort": self.cmd_sort,
-            "check": self.cmd_check,
-            "ethumb": self.cmd_ethumb, "resize": self.cmd_resize,
-            "speed": self.cmd_speed,
-            "mediainfo": self.cmd_mediainfo, "smedia": self.cmd_smedia,
             "addadmin": self.cmd_addadmin, "deladmin": self.cmd_deladmin, "admins": self.cmd_admins,
         }
         for command, kind in META_COMMANDS.items():
@@ -278,8 +246,6 @@ class App:
             return panels.filetype(s)
         if name == "help":
             return panels.help_panel()
-        if name == "formats":
-            return panels.formats_list(await self.db.list_formats(uid), for_rename=False)
         if name == "admin":
             return panels.admin(
                 self.cfg.owner_id, sorted(self.admins), self.queue.running, self.queue.waiting, self.cfg.log_channel
@@ -306,31 +272,16 @@ class App:
     async def cmd_start(self, event: Any) -> None:
         self.pending.pop(event.sender_id, None)
         text, rows = await self.panel(event.sender_id, "home")
-        banner = await self.db.get_start_media()
-        if banner:
+        if self.cfg.start_image:
             try:
-                await self._send_banner(event.chat_id, banner, text, rows)
+                await self.client.send_file(
+                    event.chat_id, self.cfg.start_image, caption=text, buttons=panels.to_buttons(rows), parse_mode="html"
+                )
                 return
             except Exception as exc:  # noqa: BLE001
-                log.warning("could not send the start banner (%s); sending text only", exc)
+                log.warning("could not send START_IMAGE (%s); sending text only", exc)
         await self._reply(event, text, rows)
 
-    async def _send_banner(self, chat_id: int, banner: Dict[str, Any], text: str, rows: List[panels.Row]) -> None:
-        is_gif = banner["kind"] == "gif"
-        bio = io.BytesIO(banner["data"])
-        bio.name = "start.gif" if is_gif else "start.jpg"
-        kwargs: Dict[str, Any] = dict(
-            caption=text, buttons=panels.to_buttons(rows), parse_mode="html",
-        )
-        if is_gif:
-            # a GIF only animates as a document carrying the animated attribute
-            kwargs["force_document"] = True
-            kwargs["attributes"] = [
-                types.DocumentAttributeFilename("start.gif"),
-                types.DocumentAttributeAnimated(),
-            ]
-        await self.client.send_file(chat_id, bio, **kwargs)
-
     async def cmd_help(self, event: Any) -> None:
         text, _ = panels.help_panel()
         await self._reply(event, text, [[("✖ Close", "x:close")]])
@@ -488,39 +439,6 @@ class App:
             await self._reply(event, "You have no thumbnail.")
 
     async def on_photo(self, event: Any) -> None:
-        uid = event.sender_id
-        p = self.pending.get(uid)
-        if p is not None and p.kind == "smedia_image":
-            raw = await event.download_media(bytes)
-            if not raw:
-                await self._reply(event, "❌ I couldn't download that photo.")
-                return
-            try:
-                data = await asyncio.to_thread(media.prepare_thumb, raw)
-            except Exception:  # noqa: BLE001
-                await self._reply(event, "❌ I couldn't read that image.")
-                return
-            await self.db.set_start_media("image", data)
-            self.pending.pop(uid, None)
-            await self._reply(event, "✅ Start image saved.")
-            return
-        if p is not None and p.kind == "fmt_thumb" and p.format_id is not None:
-            raw = await event.download_media(bytes)
-            if not raw:
-                await self._reply(event, "❌ I couldn't download that photo.")
-                return
-            try:
-                thumb = await asyncio.to_thread(media.prepare_thumb, raw)
-            except Exception:  # noqa: BLE001
-                await self._reply(event, "❌ I couldn't read that image.")
-                return
-            await self.db.update_format(uid, p.format_id, thumb=thumb)
-            self.pending.pop(uid, None)
-            text, rows = await self.format_panel(uid, p.format_id)
-            await self.client.edit_message(
-                p.chat_id, p.msg_id, text, buttons=panels.to_buttons(rows), parse_mode="html"
-            )
-            return
         raw = await event.download_media(bytes)
         if not raw:
             await self._reply(event, "❌ I couldn't download that photo.")
@@ -533,162 +451,45 @@ class App:
         await self.db.set_thumb(event.sender_id, thumb)
         await self._reply(event, "✅ Thumbnail saved. It will be used for the files I send back.", [[("🗑 Delete", "th:rm"), ("✖ Close", "x:close")]])
 
-    # --------------------------------------------------------------- sequence
-    async def cmd_sequence(self, event: Any) -> None:
-        uid = event.sender_id
-        seq = await self.db.get_sequence(uid)
-        if seq is not None:
-            await self._reply(
-                event,
-                f"🗂 You already have <b>{len(seq['items'])}</b> file(s) collected.\n"
-                "Send <code>/sort</code> to sort them, or tap Cancel.",
-                [[("✖ Cancel", "sq:cancel")]],
-            )
-            return
-        await self.db.set_sequence(uid, [])
-        status = await self._reply(
-            event,
-            "🗂 <b>Send me the files to sort.</b>\n\n"
-            "I'll work out the episode of each one and send them back in order.\n"
-            "When you're done, send <code>/sort</code>.",
-            [[("✖ Cancel", "sq:cancel")]],
-        )
-        self._seq_status[uid] = status
-
-    async def cmd_sort(self, event: Any) -> None:
-        uid = event.sender_id
-        seq = await self.db.get_sequence(uid)
-        if seq is None or not seq["items"]:
-            await self.db.clear_sequence(uid)
-            self._seq_status.pop(uid, None)
-            await self._reply(event, "You have no files to sort. Send <code>/sequence</code> first.")
-            return
-        status = await self._reply(event, "🔀 Sorting…")
-        settings = await self.db.get_settings(uid)
-        result = plan_sort(detect_episodes(seq["items"], settings["mode"]))
-        copied = int(seq.get("copied") or 0)
-        for index, item in enumerate(result.ordered):
-            if index < copied:
-                continue
-            try:
-                await self._copy_one(event.chat_id, item["msg_id"])
-            except Exception as exc:  # noqa: BLE001
-                await self.client.edit_message(
-                    status,
-                    f"❌ <b>Stopped after {copied} file(s).</b>\n"
-                    f"{esc(clip(str(exc), 200))}\n\nSend <code>/sort</code> to try the rest.",
-                    parse_mode="html",
-                )
-                return
-            copied = index + 1
-            await self.db.set_sequence(uid, seq["items"], copied=copied)
-            await asyncio.sleep(COPY_DELAY)
-        await self.db.clear_sequence(uid)
-        self._seq_status.pop(uid, None)
-        await self.client.edit_message(status, format_report(result, len(result.ordered)), parse_mode="html")
-
-    async def _copy_one(self, chat_id: int, msg_id: int) -> None:
-        """Send one message back into the chat, without a "forwarded from" header.
-
-        Telethon has no true copy (that is Bot-API only), so this forwards the
-        message with ``drop_author`` — the attribution line is dropped, so the
-        file reads as if the bot had posted it.  Waiting out a flood wait.
-        """
-        try:
-            await self.client.forward_messages(chat_id, [msg_id], chat_id, drop_author=True)
-        except errors.FloodWaitError as exc:
-            await asyncio.sleep(exc.seconds)
-            await self.client.forward_messages(chat_id, [msg_id], chat_id, drop_author=True)
-
-    async def _collect_file(self, event: Any) -> None:
-        """Add an incoming file to the open sequence instead of renaming it."""
-        uid = event.sender_id
-        msg = event.message
-        seq = await self.db.get_sequence(uid) or {"items": [], "copied": 0}
-        items = list(seq["items"])
-        items.append({"msg_id": msg.id, "name": original_name_of(msg), "caption": msg.raw_text or ""})
-        await self.db.set_sequence(uid, items, copied=int(seq.get("copied") or 0))
-        text = (
-            f"🗂 <b>{len(items)}</b> file(s) collected.\n"
-            "Send <code>/sort</code> when you're done."
-        )
-        status = self._seq_status.get(uid)
-        if status is not None:
-            try:
-                await self.client.edit_message(status, text, parse_mode="html")
-                return
-            except Exception:  # noqa: BLE001
-                self._seq_status.pop(uid, None)
-        self._seq_status[uid] = await self._reply(event, text)
-
     # ------------------------------------------------------------ rename flow
     async def cmd_rename(self, event: Any) -> None:
-        uid = event.sender_id
-        if self._args(event):
-            await self._reply(
-                event,
-                "❌ /rename doesn't take a name any more.\nPick a format, then send me the file.",
-            )
+        arg = self._args(event)
+        reply = await event.get_reply_message()
+        if reply is None or not is_renameable(reply) or not arg:
+            await self._reply(event, "Reply to a file with <code>/rename New Name</code>.\nThe extension always stays the same.")
             return
-        formats = await self.db.list_formats(uid)
-        text, rows = panels.formats_list(formats, for_rename=True)
-        await self._reply(event, text, rows)
-
-    async def cmd_formats(self, event: Any) -> None:
-        formats = await self.db.list_formats(event.sender_id)
-        text, rows = panels.formats_list(formats, for_rename=False)
-        await self._reply(event, text, rows)
-
-    async def format_panel(self, uid: int, fmt_id: int) -> panels.Panel:
-        fmt = await self.db.get_format(uid, fmt_id)
-        if fmt is None:
-            return panels.formats_list(await self.db.list_formats(uid), for_rename=False)
-        return panels.format_editor(fmt)
+        await self.enqueue(event, reply, manual=arg)
 
     async def on_media(self, event: Any) -> None:
-        uid = event.sender_id
-        p = self.pending.get(uid)
-        fmt = None
-        if p is not None and p.kind == "rename_format" and p.format_id is not None:
-            fmt = await self.db.get_format(uid, p.format_id)
-            self.pending.pop(uid, None)
-            if fmt is None:
-                await self._reply(event, "❌ That format is gone — pick another one with /rename.")
-                return
-        elif await self.db.get_sequence(uid) is not None:
-            await self._collect_file(event)
-            return
-        await self.enqueue(event, event.message, fmt=fmt)
+        await self.enqueue(event, event.message)
 
-    async def enqueue(self, event: Any, msg: Any, fmt: Optional[Dict[str, Any]] = None) -> None:
+    async def enqueue(self, event: Any, msg: Any, manual: Optional[str] = None) -> None:
         uid = event.sender_id
         size = int(msg.file.size or 0) if msg.file is not None else 0
         if size > self.cfg.max_file_bytes:
             await self._reply(event, f"❌ That file is {human_size(size)}; the limit is {human_size(self.cfg.max_file_bytes)}.")
             return
         s = await self.db.get_settings(uid)
-        thumb_mode, thumb = "auto", None
-        if fmt is not None:
-            s = resolve_format(fmt, s)
-            thumb_mode, thumb = resolve_thumbnail(fmt, await self.db.get_thumb(uid))
         orig = original_name_of(msg)
         ext = source_ext(msg, orig)
         notes: List[str] = []
-        new_name, info = compute_new_name(
-            template=s["template"], mode=s["mode"], original_name=orig, original_ext=ext,
-            caption=msg.raw_text or "", remove_words=s["remove_words"],
-        )
-        gaps = missing_variables(s["template"], info)
-        if gaps:
-            where_from = "caption" if s["mode"] == "caption" else "file name"
-            notes.append(
-                "Couldn't find " + ", ".join("{%s}" % g for g in gaps) + f" in the {where_from}, so it is left empty. "
-                "Cancel and use /rename, or change the template."
+        if manual:
+            new_name = build_manual_name(manual, ext)
+        else:
+            new_name, info = compute_new_name(
+                template=s["template"], mode=s["mode"], original_name=orig, original_ext=ext,
+                caption=msg.raw_text or "", remove_words=s["remove_words"],
             )
+            gaps = missing_variables(s["template"], info)
+            if gaps:
+                where_from = "caption" if s["mode"] == "caption" else "file name"
+                notes.append(
+                    "Couldn't find " + ", ".join("{%s}" % g for g in gaps) + f" in the {where_from}, so it is left empty. "
+                    "Cancel and use /rename, or change the template."
+                )
         job = Job(
             id=self.queue.new_id(), user_id=uid, chat_id=event.chat_id, msg_id=msg.id,
-            file_name=orig, size=size, new_name=new_name, notes=notes, order=event.id,
-            settings_override=s, thumbnail_mode=thumb_mode, thumbnail=thumb,
+            file_name=orig, size=size, new_name=new_name, manual=bool(manual), notes=notes, order=event.id,
         )
         ahead = self.queue.running + self.queue.waiting
         where = "starting soon" if ahead == 0 else f"{ahead} ahead of it"
@@ -735,179 +536,6 @@ class App:
         count = self.queue.cancel_all() if (arg == "all" and self.is_owner(uid)) else self.queue.cancel_user(uid)
         await self._reply(event, f"🛑 Cancelling {count} job(s)…" if count else "You have no active jobs.")
 
-    # ------------------------------------------------------------------ check
-    async def cmd_check(self, event: Any) -> None:
-        reply = await event.get_reply_message()
-        if reply is None or not is_renameable(reply):
-            await self._reply(event, "Reply to a file with <code>/check</code> to see what I can read from it.")
-            return
-        name = original_name_of(reply)
-        stem, _ext = split_ext(name)
-        file_info = parse_info(stem)
-        caption_info = effective_info(stem, reply.raw_text or "", "caption")
-        await self._reply(event, panels.check_report(file_info, caption_info))
-
-    # ------------------------------------------------------------- thumbnails
-    async def cmd_ethumb(self, event: Any) -> None:
-        reply = await event.get_reply_message()
-        if reply is None or not is_renameable(reply):
-            await self._reply(event, "Reply to a video or file with <code>/ethumb</code> to take a thumbnail from it.")
-            return
-        status = await self._reply(event, "🔎 Looking for a frame…")
-        name = original_name_of(reply)
-        ext = source_ext(reply, name)
-        tmp_dir = Path(self.cfg.temp_dir) / f"ethumb{event.chat_id}_{event.id}"
-        tmp_dir.mkdir(parents=True, exist_ok=True)
-        try:
-            path = tmp_dir / f"src{ext}"
-            await transfer.download(self.client, reply, path, fast=self.cfg.fast_transfer, connections=2)
-            try:
-                info = await media.probe(path)
-            except media.MediaError:
-                info = None
-            if info is None or not info.of("video"):
-                await self.client.edit_message(
-                    status, "❌ That file has no video — I can't take a thumbnail from it.", parse_mode="html"
-                )
-                return
-            frame = tmp_dir / "thumb.jpg"
-            if not await media.extract_frame(path, frame, info.duration):
-                await self.client.edit_message(
-                    status, "❌ I couldn't grab a frame from that file.", parse_mode="html"
-                )
-                return
-            data = frame.read_bytes()
-            self._ethumbs[event.sender_id] = data
-            await self.client.edit_message(status, "🖼 Here's the frame:", parse_mode="html")
-            await self.client.send_file(
-                event.chat_id, io.BytesIO(data), caption="Extracted frame",
-                buttons=panels.to_buttons([[("Set as my thumbnail", "eth:set"), ("✖ Close", "x:close")]]),
-            )
-        finally:
-            shutil.rmtree(tmp_dir, ignore_errors=True)
-
-    async def cmd_resize(self, event: Any) -> None:
-        reply = await event.get_reply_message()
-        data = None
-        if reply is not None and is_image(reply):
-            data = await reply.download_media(bytes)
-        if not data:
-            await self._reply(event, "Reply to an image with <code>/resize</code>.")
-            return
-        self._resize_source[event.sender_id] = data
-        await self._reply(
-            event,
-            "🖼 How big should it be?",
-            [
-                [("320", "rz:320"), ("640", "rz:640"), ("1280", "rz:1280")],
-                [("Original", "rz:orig"), ("Custom", "rz:custom")],
-                [("✖ Close", "x:close")],
-            ],
-        )
-
-    async def _cb_resize(self, event: Any, uid: int, size: str) -> None:
-        source = self._resize_source.get(uid)
-        if source is None:
-            await event.answer("That image is gone — run /resize again.", alert=True)
-            return
-        if size == "custom":
-            self.pending[uid] = Pending(
-                kind="resize_size", chat_id=event.chat_id, msg_id=event.message_id,
-                back="formats", is_photo=False, expires=time.time() + self.PENDING_TTL,
-            )
-            await event.answer()
-            await self._edit_panel(
-                event,
-                "Send the size: a number for the width (<code>800</code>) or <code>800x450</code>.",
-                [[("✖ Cancel", "x:close")]],
-            )
-            return
-        try:
-            data = source if size == "orig" else media.resize_image(source, width=int(size))
-        except Exception as exc:  # noqa: BLE001
-            await event.answer(f"I couldn't resize that: {exc}", alert=True)
-            return
-        await self._send_resized(event, uid, data)
-
-    async def _send_resized(self, event: Any, uid: int, data: bytes) -> None:
-        self._ethumbs[uid] = data
-        await self.client.send_file(
-            event.chat_id, io.BytesIO(data), caption="Resized image",
-            buttons=panels.to_buttons([[("Set as my thumbnail", "eth:set"), ("✖ Close", "x:close")]]),
-        )
-        await event.answer()
-
-    # --------------------------------------------------------------- mediainfo
-    async def cmd_mediainfo(self, event: Any) -> None:
-        reply = await event.get_reply_message()
-        if reply is None or not is_renameable(reply):
-            await self._reply(event, "Reply to a file with <code>/mediainfo</code> to see everything about it.")
-            return
-        status = await self._reply(event, "🔎 Reading the file…")
-        name = original_name_of(reply)
-        ext = source_ext(reply, name)
-        tmp_dir = Path(self.cfg.temp_dir) / f"mi{event.chat_id}_{event.id}"
-        tmp_dir.mkdir(parents=True, exist_ok=True)
-        try:
-            path = tmp_dir / f"src{ext}"
-            await transfer.download(
-                self.client, reply, path, fast=self.cfg.fast_transfer, connections=self.cfg.connections
-            )
-            probe = await media.probe_full(path)
-            url = await self._publish_media_info(probe, name)
-            if url:
-                await self.client.edit_message(
-                    status, f"📋 <b>Media info</b>\n<a href=\"{esc(url)}\">open the report</a>", parse_mode="html"
-                )
-                return
-            summary = clip(telegraph.build_summary(probe, name), 3500)
-            await self.client.edit_message(
-                status, f"📋 <b>Media info</b> (telegra.ph is unreachable, so here it is)\n\n{esc(summary)}",
-                parse_mode="html",
-            )
-        except Exception as exc:  # noqa: BLE001
-            await self.client.edit_message(
-                status, f"❌ I couldn't read that file: {esc(clip(str(exc), 200))}", parse_mode="html"
-            )
-        finally:
-            shutil.rmtree(tmp_dir, ignore_errors=True)
-
-    async def _publish_media_info(self, probe: Dict[str, Any], name: str) -> str:
-        """Upload the report to telegra.ph and return its URL ('' when it fails)."""
-        try:
-            token = await self.db.kv_get("telegraph_token")
-            if not token:
-                token = await telegraph.Telegraph().create_account()
-                if token:
-                    await self.db.kv_set("telegraph_token", token)
-            if not token:
-                return ""
-            page = telegraph.build_page(probe, name)
-            return await telegraph.Telegraph(token).upload_page(f"Media info — {name}", [page])
-        except Exception as exc:  # noqa: BLE001
-            log.warning("telegra.ph upload failed: %s", exc)
-            return ""
-
-    # ------------------------------------------------------------------ speed
-    async def cmd_speed(self, event: Any) -> None:
-        status = await self._reply(event, "📡 Testing your connection…")
-        try:
-            result = await run_speedtest()
-        except FileNotFoundError:
-            await self.client.edit_message(
-                status, "❌ The speedtest tool isn't installed in this container.", parse_mode="html"
-            )
-            return
-        except asyncio.TimeoutError:
-            await self.client.edit_message(status, "❌ The speed test timed out.", parse_mode="html")
-            return
-        except Exception as exc:  # noqa: BLE001
-            await self.client.edit_message(
-                status, f"❌ The speed test failed: {esc(clip(str(exc), 200))}", parse_mode="html"
-            )
-            return
-        await self.client.edit_message(status, format_speed(result), parse_mode="html")
-
     # ------------------------------------------------------------------ tracks
     async def cmd_tracks(self, event: Any) -> None:
         reply = await event.get_reply_message()
@@ -1002,15 +630,6 @@ class App:
         if p is None or p.expires < time.time():
             self.pending.pop(uid, None)
             return
-        if p.kind == "rename_format":
-            await self._reply(event, "Send me the <b>file</b> to rename, not text.")
-            return
-        if p.kind == "resize_size":
-            await self._on_resize_text(event, uid, p)
-            return
-        if p.format_id is not None or p.kind == "fmt_name":
-            await self._on_format_text(event, uid, p)
-            return
         ok, msg = await apply_setting(self.db, uid, p.kind, event.raw_text)
         if not ok:
             await self._reply(event, msg + "\n\nTry again, or tap Cancel.")
@@ -1028,179 +647,7 @@ class App:
         except Exception:  # noqa: BLE001
             await self._reply(event, full, rows)
 
-    async def _on_resize_text(self, event: Any, uid: int, p: Pending) -> None:
-        """Handle the size the user typed for a custom /resize."""
-        width, height, error = media.parse_size(event.raw_text or "")
-        if error:
-            await self._reply(event, "❌ " + error)
-            return
-        source = self._resize_source.get(uid)
-        if not source:
-            self.pending.pop(uid, None)
-            await self._reply(event, "❌ That image is gone — run /resize again.")
-            return
-        try:
-            data = media.resize_image(source, width=width, height=height)
-        except Exception as exc:  # noqa: BLE001
-            await self._reply(event, f"❌ I couldn't resize that: {esc(clip(str(exc), 120))}")
-            return
-        self.pending.pop(uid, None)
-        self._ethumbs[uid] = data
-        await self.client.send_file(
-            event.chat_id, io.BytesIO(data), caption="Resized image",
-            buttons=panels.to_buttons([[("Set as my thumbnail", "eth:set"), ("✖ Close", "x:close")]]),
-        )
-
-    # ------------------------------------------------------------------ smedia
-    async def cmd_smedia(self, event: Any) -> None:
-        banner = await self.db.get_start_media()
-        kind = banner["kind"] if banner else None
-        text, rows = panels.smedia_panel(kind, banner is not None)
-        await self._reply(event, text, rows)
-
-    async def on_animation(self, event: Any) -> None:
-        """Catches a GIF sent while the owner is setting the start screen."""
-        uid = event.sender_id
-        p = self.pending.get(uid)
-        if p is None or p.kind != "smedia_gif":
-            return
-        raw = await event.download_media(bytes)
-        if not raw:
-            await self._reply(event, "❌ I couldn't download that GIF.")
-            return
-        await self.db.set_start_media("gif", raw)
-        self.pending.pop(uid, None)
-        await self._reply(event, "✅ Start GIF saved.")
-
     # ---------------------------------------------------------------- callbacks
-    async def _on_format_text(self, event: Any, uid: int, p: Pending) -> None:
-        """Handle a text reply that fills in one field of a saved format."""
-        text = (event.raw_text or "").strip()
-        fmt_id = p.format_id
-        if p.kind == "fmt_name" and fmt_id is None:
-            created = await self.db.create_format(uid, text)
-            if created is None:
-                await self._reply(event, "❌ That name won't do — send a different one.")
-                return
-            fmt_id = created["id"]
-            message = f"✅ Created <b>{esc(created['name'])}</b>."
-        else:
-            ok, message = await apply_format_field(self.db, uid, fmt_id, p.kind, text)
-            if not ok:
-                await self._reply(event, message + "\n\nTry again, or tap Cancel.")
-                return
-        self.pending.pop(uid, None)
-        try:
-            await event.delete()
-        except Exception:  # noqa: BLE001
-            pass
-        panel_text, rows = await self.format_panel(uid, fmt_id)
-        full = (
-            f"{message}\n\n{panel_text}"
-            if visible_len(message) + visible_len(panel_text) < 3900
-            else f"{message}\n\n(Open the menu to see the update.)"
-        )
-        try:
-            await self.client.edit_message(
-                p.chat_id, p.msg_id, full, buttons=panels.to_buttons(rows), parse_mode="html"
-            )
-        except Exception:  # noqa: BLE001
-            await self._reply(event, full, rows)
-
-    async def _cb_use_format(self, event: Any, uid: int, fmt_id: int) -> None:
-        fmt = await self.db.get_format(uid, fmt_id)
-        if fmt is None:
-            await event.answer("That format is gone.", alert=True)
-            return
-        self.pending[uid] = Pending(
-            kind="rename_format", chat_id=event.chat_id, msg_id=event.message_id,
-            back="formats", is_photo=False, expires=time.time() + self.PENDING_TTL, format_id=fmt_id,
-        )
-        await event.answer()
-        await self._edit_panel(
-            event, f"✅ <b>{esc(fmt['name'])}</b>\n\nSend me the file to rename with it.", [[("✖ Close", "x:close")]]
-        )
-
-    async def _cb_open_format(self, event: Any, uid: int, fmt_id: int) -> None:
-        text, rows = await self.format_panel(uid, fmt_id)
-        await self._edit_panel(event, text, rows)
-        await event.answer()
-
-    async def _cb_new_format(self, event: Any, uid: int) -> None:
-        if await self.db.count_formats(uid) >= MAX_FORMATS:
-            await event.answer(f"You already have {MAX_FORMATS} formats.", alert=True)
-            return
-        self.pending[uid] = Pending(
-            kind="fmt_name", chat_id=event.chat_id, msg_id=event.message_id,
-            back="formats", is_photo=False, expires=time.time() + self.PENDING_TTL,
-        )
-        await event.answer()
-        await self._edit_panel(
-            event, panels.FORMAT_PROMPTS["fmt_name"], [[("✖ Cancel", "x:close")]]
-        )
-
-    async def _cb_set_format_field(self, event: Any, uid: int, kind: str, fmt_id: int) -> None:
-        if await self.db.get_format(uid, fmt_id) is None:
-            await event.answer("That format is gone.", alert=True)
-            return
-        self.pending[uid] = Pending(
-            kind=kind, chat_id=event.chat_id, msg_id=event.message_id,
-            back="formats", is_photo=False, expires=time.time() + self.PENDING_TTL, format_id=fmt_id,
-        )
-        await event.answer()
-        await self._edit_panel(
-            event, panels.FORMAT_PROMPTS[kind], [[("✖ Cancel", "x:close")]]
-        )
-
-    async def _cb_format_thumb(self, event: Any, uid: int, action: str, fmt_id: int) -> None:
-        if await self.db.get_format(uid, fmt_id) is None:
-            await event.answer("That format is gone.", alert=True)
-            return
-        if action == "fthumb":
-            self.pending[uid] = Pending(
-                kind="fmt_thumb", chat_id=event.chat_id, msg_id=event.message_id,
-                back="formats", is_photo=True, expires=time.time() + self.PENDING_TTL, format_id=fmt_id,
-            )
-            await event.answer()
-            await self._edit_panel(
-                event, "Send me the photo to use as this format's thumbnail.", [[("✖ Cancel", "x:close")]]
-            )
-            return
-        if action == "fthumbdef":
-            await self.db.update_format(uid, fmt_id, thumb=None)
-            toast = "Thumbnail back to your default."
-        else:
-            await self.db.update_format(uid, fmt_id, thumb=b"")
-            toast = "No thumbnail for this format."
-        text, rows = await self.format_panel(uid, fmt_id)
-        await self._edit_panel(event, text, rows)
-        await event.answer(toast)
-
-    async def _cb_rename_format(self, event: Any, uid: int, fmt_id: int) -> None:
-        if await self.db.get_format(uid, fmt_id) is None:
-            await event.answer("That format is gone.", alert=True)
-            return
-        self.pending[uid] = Pending(
-            kind="fmt_name", chat_id=event.chat_id, msg_id=event.message_id,
-            back="formats", is_photo=False, expires=time.time() + self.PENDING_TTL, format_id=fmt_id,
-        )
-        await event.answer()
-        await self._edit_panel(
-            event, panels.FORMAT_PROMPTS["fmt_name"], [[("✖ Cancel", "x:close")]]
-        )
-
-    async def _cb_delete_format(self, event: Any, uid: int, fmt_id: int) -> None:
-        fmt = await self.db.get_format(uid, fmt_id)
-        if fmt is None:
-            await event.answer("That format is gone.", alert=True)
-            return
-        await self._edit_panel(
-            event,
-            f"🗑 Delete <b>{esc(fmt['name'])}</b>?",
-            [[("Yes, delete it", f"fdelok:{fmt_id}"), ("✖ Keep it", f"fl:{fmt_id}")]],
-        )
-        await event.answer()
-
     async def on_callback(self, event: Any) -> None:
         uid = event.sender_id
         data = event.data.decode("utf-8", "ignore")
@@ -1213,62 +660,6 @@ class App:
             await self._remove_message(event)
             return
 
-        if data == "sq:cancel":
-            await self.db.clear_sequence(uid)
-            self._seq_status.pop(uid, None)
-            await event.answer("Sequence cancelled.")
-            await self._remove_message(event)
-            return
-
-        if data == "eth:set":
-            data_bytes = self._ethumbs.get(uid)
-            if not data_bytes:
-                await event.answer("That image is gone — run /ethumb or /resize again.", alert=True)
-                return
-            try:
-                thumb = await asyncio.to_thread(media.prepare_thumb, data_bytes)
-            except Exception:  # noqa: BLE001
-                await event.answer("I couldn't read that image.", alert=True)
-                return
-            await self.db.set_thumb(uid, thumb)
-            await event.answer("Thumbnail saved.")
-            return
-
-        if head == "rz" and len(parts) == 2 and parts[1]:
-            await self._cb_resize(event, uid, parts[1])
-            return
-
-        if data in ("smedia:image", "smedia:gif"):
-            kind = "smedia_image" if data.endswith("image") else "smedia_gif"
-            self.pending[uid] = Pending(
-                kind=kind, chat_id=event.chat_id, msg_id=event.message_id,
-                back="home", is_photo=kind == "smedia_image",
-                expires=time.time() + self.PENDING_TTL,
-            )
-            await event.answer()
-            await self._edit_panel(
-                event,
-                "Send me the image." if kind == "smedia_image" else "Send me the GIF.",
-                [[("✖ Cancel", "x:close")]],
-            )
-            return
-
-        if data == "smedia:view":
-            banner = await self.db.get_start_media()
-            if not banner:
-                await event.answer("There is no start screen yet.", alert=True)
-                return
-            await event.answer()
-            await self._send_banner(event.chat_id, banner, "This is the start screen.", [])
-            return
-
-        if data == "smedia:del":
-            await self.db.clear_start_media()
-            text, rows = panels.smedia_panel(None, False)
-            await self._edit_panel(event, text, rows)
-            await event.answer("Start screen deleted.")
-            return
-
         if head == "m" and len(parts) == 2 and parts[1] in PANEL_NAMES:
             self.pending.pop(uid, None)
             if parts[1] == "admin" and not self.is_owner(uid):
@@ -1283,42 +674,6 @@ class App:
             await self._cb_set(event, uid, parts[1], parts[2])
             return
 
-        if head == "fm" and len(parts) == 2 and parts[1].isdigit():
-            await self._cb_use_format(event, uid, int(parts[1]))
-            return
-
-        if head == "fl" and len(parts) == 2 and parts[1].isdigit():
-            await self._cb_open_format(event, uid, int(parts[1]))
-            return
-
-        if data == "fnew":
-            await self._cb_new_format(event, uid)
-            return
-
-        if head == "fset" and len(parts) == 3 and parts[1] in panels.FORMAT_PROMPTS and parts[2].isdigit():
-            await self._cb_set_format_field(event, uid, parts[1], int(parts[2]))
-            return
-
-        if head in ("fthumb", "fthumbdef", "fthumbnone") and len(parts) == 2 and parts[1].isdigit():
-            await self._cb_format_thumb(event, uid, head, int(parts[1]))
-            return
-
-        if head == "frename" and len(parts) == 2 and parts[1].isdigit():
-            await self._cb_rename_format(event, uid, int(parts[1]))
-            return
-
-        if head == "fdel" and len(parts) == 2 and parts[1].isdigit():
-            await self._cb_delete_format(event, uid, int(parts[1]))
-            return
-
-        if head == "fdelok" and len(parts) == 2 and parts[1].isdigit():
-            fmt_id = int(parts[1])
-            ok = await self.db.delete_format(uid, fmt_id)
-            text, rows = panels.formats_list(await self.db.list_formats(uid), for_rename=False)
-            await self._edit_panel(event, text, rows)
-            await event.answer("Format deleted." if ok else "That format is gone.")
-            return
-
         if head == "in":
             await self._cb_input(event, uid, parts)
             return
@@ -1415,7 +770,7 @@ class App:
             await event.answer("Cancelled.")
             return
         kind = parts[1] if len(parts) == 2 else ""
-        if kind not in panels.PROMPTS or kind.startswith("fmt"):
+        if kind not in panels.PROMPTS:
             await event.answer()
             return
         msg_obj = await event.get_message()

bot/config.py

@@ -50,6 +50,7 @@ class Config:
     database_url: str
     session_string: str
     log_channel: Optional[int]
+    start_image: Optional[str]
     port: int
     temp_dir: str
     max_jobs: int
@@ -90,6 +91,7 @@ def load_config(env: Optional[Mapping[str, str]] = None) -> Config:
         database_url=env.get("DATABASE_URL", "").strip() or "sqlite+aiosqlite:///bot.db",
         session_string=env.get("SESSION_STRING", "").strip(),
         log_channel=log_channel,
+        start_image=env.get("START_IMAGE", "").strip() or None,
         port=_get_int(env, "PORT", 7860),
         temp_dir=env.get("TEMP_DIR", "").strip() or "/tmp/rename",
         max_jobs=max_jobs,

bot/db.py

@@ -12,7 +12,7 @@ from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from sqlalchemy import BigInteger, DateTime, Integer, LargeBinary, String, Text, UniqueConstraint, func, select
+from sqlalchemy import BigInteger, DateTime, Integer, LargeBinary, String, Text, func, select
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
@@ -20,9 +20,6 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from .parser import DEFAULT_TEMPLATE
 
-MAX_FORMATS = 12
-META_FIELDS = ("title", "author", "artist", "audio", "subtitle", "video")
-
 DEFAULT_SETTINGS: Dict[str, Any] = {
     "mode": "filename",  # filename | caption
     "template": DEFAULT_TEMPLATE,
@@ -71,50 +68,6 @@ class KV(Base):
     value: Mapped[str] = mapped_column(Text, default="")
 
 
-class Format(Base):
-    """A saved, named rename format.
-
-    Every field is tri-state: ``NULL`` means "inherit the user's global
-    setting", while a stored value overrides it.  ``keep_audio`` /
-    ``keep_subtitle`` store JSON, so ``NULL`` (inherit) stays distinct from
-    ``[]`` (explicitly keep every track).
-    """
-
-    __tablename__ = "formats"
-    __table_args__ = (UniqueConstraint("user_id", "name"),)
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    user_id: Mapped[int] = mapped_column(BigInteger, index=True)
-    name: Mapped[str] = mapped_column(String(64))
-    position: Mapped[int] = mapped_column(Integer, default=0)
-    template: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-    thumb: Mapped[Optional[bytes]] = mapped_column(LargeBinary, nullable=True)
-    meta: Mapped[str] = mapped_column(Text, default="{}")
-    keep_audio: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-    keep_subtitle: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-
-
-class SequenceRow(Base):
-    """Files collected for a ``/sequence`` batch, waiting to be sorted."""
-
-    __tablename__ = "sequences"
-
-    user_id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
-    items: Mapped[str] = mapped_column(Text, default="[]")
-    copied: Mapped[int] = mapped_column(Integer, default=0)
-    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
-
-
-class BotMedia(Base):
-    """The banner shown on ``/start`` (one row, id 1)."""
-
-    __tablename__ = "bot_media"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    kind: Mapped[str] = mapped_column(String(8))
-    data: Mapped[bytes] = mapped_column(LargeBinary)
-
-
 def normalize_database_url(url: str) -> Tuple[str, Dict[str, Any]]:
     """Turn a provider URL into something SQLAlchemy's async drivers accept."""
     connect_args: Dict[str, Any] = {}
@@ -133,17 +86,6 @@ def normalize_database_url(url: str) -> Tuple[str, Dict[str, Any]]:
     return url, connect_args
 
 
-def _decode_list(raw: Optional[str]) -> Optional[List[str]]:
-    """``NULL`` stays ``None`` (inherit); a JSON array decodes to a list."""
-    if raw is None:
-        return None
-    try:
-        value = json.loads(raw)
-    except ValueError:
-        return None
-    return list(value) if isinstance(value, list) else None
-
-
 def _merge_settings(stored: Dict[str, Any]) -> Dict[str, Any]:
     merged = copy.deepcopy(DEFAULT_SETTINGS)
     for key, value in stored.items():
@@ -271,189 +213,6 @@ class Database:
             await session.commit()
             return True
 
-    # ----- formats --------------------------------------------------------------------
-    @staticmethod
-    def _format_dict(row: Format) -> Dict[str, Any]:
-        try:
-            meta = json.loads(row.meta or "{}")
-        except ValueError:
-            meta = {}
-        if not isinstance(meta, dict):
-            meta = {}
-        return {
-            "id": row.id,
-            "name": row.name,
-            "template": row.template,
-            "thumb": bytes(row.thumb) if row.thumb is not None else None,
-            "meta": {field: meta.get(field) for field in META_FIELDS},
-            "keep_audio": _decode_list(row.keep_audio),
-            "keep_subtitle": _decode_list(row.keep_subtitle),
-        }
-
-    async def list_formats(self, uid: int) -> List[Dict[str, Any]]:
-        async with self._sessions() as session:
-            rows = (
-                await session.execute(
-                    select(Format).where(Format.user_id == uid).order_by(Format.position, Format.id)
-                )
-            ).scalars().all()
-            return [self._format_dict(row) for row in rows]
-
-    async def get_format(self, uid: int, fmt_id: int) -> Optional[Dict[str, Any]]:
-        async with self._sessions() as session:
-            row = await session.get(Format, fmt_id)
-            if row is None or row.user_id != uid:
-                return None
-            return self._format_dict(row)
-
-    async def count_formats(self, uid: int) -> int:
-        async with self._sessions() as session:
-            result = await session.execute(
-                select(func.count()).select_from(Format).where(Format.user_id == uid)
-            )
-            return int(result.scalar() or 0)
-
-    async def create_format(self, uid: int, name: str) -> Optional[Dict[str, Any]]:
-        """Create a format.  ``None`` when the name is taken, blank or the 12-slot limit is hit."""
-        name = (name or "").strip()
-        if not name:
-            return None
-        async with self._sessions() as session:
-            clash = (
-                await session.execute(select(Format).where(Format.user_id == uid, Format.name == name))
-            ).scalars().first()
-            if clash is not None:
-                return None
-            count = int(
-                (
-                    await session.execute(
-                        select(func.count()).select_from(Format).where(Format.user_id == uid)
-                    )
-                ).scalar()
-                or 0
-            )
-            if count >= MAX_FORMATS:
-                return None
-            row = Format(
-                user_id=uid,
-                name=name,
-                position=count,
-                meta=json.dumps({field: None for field in META_FIELDS}),
-            )
-            session.add(row)
-            await session.commit()
-            return self._format_dict(row)
-
-    async def update_format(self, uid: int, fmt_id: int, **changes: Any) -> bool:
-        """Update a format.  Only the keys passed in are touched."""
-        allowed = {"name", "template", "thumb", "meta", "keep_audio", "keep_subtitle"}
-        if not changes or not set(changes) <= allowed:
-            return False
-        async with self._sessions() as session:
-            row = await session.get(Format, fmt_id)
-            if row is None or row.user_id != uid:
-                return False
-            if "name" in changes:
-                name = (changes["name"] or "").strip()
-                if not name:
-                    return False
-                clash = (
-                    await session.execute(
-                        select(Format).where(
-                            Format.user_id == uid, Format.name == name, Format.id != fmt_id
-                        )
-                    )
-                ).scalars().first()
-                if clash is not None:
-                    return False
-                row.name = name
-            if "template" in changes:
-                row.template = changes["template"]
-            if "thumb" in changes:
-                value = changes["thumb"]
-                row.thumb = None if value is None else bytes(value)
-            if "meta" in changes:
-                try:
-                    current = json.loads(row.meta or "{}")
-                except ValueError:
-                    current = {}
-                if not isinstance(current, dict):
-                    current = {}
-                for field, value in (changes["meta"] or {}).items():
-                    if field in META_FIELDS:
-                        current[field] = value
-                row.meta = json.dumps(current, ensure_ascii=False)
-            for key in ("keep_audio", "keep_subtitle"):
-                if key in changes:
-                    value = changes[key]
-                    setattr(row, key, None if value is None else json.dumps(list(value), ensure_ascii=False))
-            await session.commit()
-            return True
-
-    async def delete_format(self, uid: int, fmt_id: int) -> bool:
-        async with self._sessions() as session:
-            row = await session.get(Format, fmt_id)
-            if row is None or row.user_id != uid:
-                return False
-            await session.delete(row)
-            await session.commit()
-            return True
-
-    # ----- sequences ---------------------------------------------------------------------
-    async def get_sequence(self, uid: int) -> Optional[Dict[str, Any]]:
-        async with self._sessions() as session:
-            row = await session.get(SequenceRow, uid)
-            if row is None:
-                return None
-            try:
-                items = json.loads(row.items or "[]")
-            except ValueError:
-                items = []
-            return {"items": items if isinstance(items, list) else [], "copied": int(row.copied or 0)}
-
-    async def set_sequence(self, uid: int, items: List[Dict[str, Any]], copied: int = 0) -> None:
-        async with self._sessions() as session:
-            row = await session.get(SequenceRow, uid)
-            if row is None:
-                row = SequenceRow(user_id=uid, items="[]", copied=0)
-                session.add(row)
-            row.items = json.dumps(items, ensure_ascii=False)
-            row.copied = int(copied)
-            row.updated_at = _utcnow()
-            await session.commit()
-
-    async def clear_sequence(self, uid: int) -> None:
-        async with self._sessions() as session:
-            row = await session.get(SequenceRow, uid)
-            if row is not None:
-                await session.delete(row)
-                await session.commit()
-
-    # ----- start banner ---------------------------------------------------------------------
-    async def get_start_media(self) -> Optional[Dict[str, Any]]:
-        async with self._sessions() as session:
-            row = await session.get(BotMedia, 1)
-            if row is None:
-                return None
-            return {"kind": row.kind, "data": bytes(row.data)}
-
-    async def set_start_media(self, kind: str, data: bytes) -> None:
-        async with self._sessions() as session:
-            row = await session.get(BotMedia, 1)
-            if row is None:
-                session.add(BotMedia(id=1, kind=kind, data=data))
-            else:
-                row.kind = kind
-                row.data = data
-            await session.commit()
-
-    async def clear_start_media(self) -> None:
-        async with self._sessions() as session:
-            row = await session.get(BotMedia, 1)
-            if row is not None:
-                await session.delete(row)
-                await session.commit()
-
     # ----- key/value (session string etc.) ---------------------------------------------
     async def kv_get(self, key: str) -> Optional[str]:
         async with self._sessions() as session:

bot/formats.py

@@ -1,160 +0,0 @@
-"""Saved rename formats: the per-user named templates.
-
-A format carries its own template, thumbnail, metadata and track-keep lists.
-Every field is **tri-state**:
-
-* ``None``  — inherit the user's global setting for that field
-* ``""`` / ``[]`` — explicitly empty, overriding the global setting
-* a value  — an override
-
-The distinction matters: without it there would be no way to say "this format keeps
-every track" when the global keep-audio list is set, and no way to say "this format
-has no title" when the global title is set.
-"""
-from __future__ import annotations
-
-import copy
-from typing import Any, Dict, List, Optional, Tuple
-
-from .db import META_FIELDS, MAX_FORMATS, Database
-from .media import parse_track_tokens, validate_track_tokens
-from .panels import fmt_tokens
-from .settings_ops import CLEAR_WORDS, preview_template
-from .utils import clip, esc
-
-META_KINDS = {
-    "fmt_title": "title",
-    "fmt_author": "author",
-    "fmt_artist": "artist",
-    "fmt_audio": "audio",
-    "fmt_subtitle": "subtitle",
-    "fmt_video": "video",
-}
-
-KEEP_KINDS = {
-    "fmt_keep_audio": "keep_audio",
-    "fmt_keep_subtitle": "keep_subtitle",
-}
-
-MAX_TEMPLATE_LEN = 200
-MAX_META_LEN = 200
-MAX_TRACKS = 12
-DEFAULT_WORDS = {"default", "inherit", "my default"}
-
-__all__ = [
-    "MAX_FORMATS",
-    "META_FIELDS",
-    "META_KINDS",
-    "apply_format_field",
-    "resolve_format",
-    "resolve_thumbnail",
-]
-
-
-def _is_clear(text: str) -> bool:
-    return text.strip().lower() in CLEAR_WORDS
-
-
-def _is_default(text: str) -> bool:
-    """``default`` means "go back to my global setting"."""
-    return text.strip().lower() in DEFAULT_WORDS
-
-
-def resolve_format(fmt: Dict[str, Any], settings: Dict[str, Any]) -> Dict[str, Any]:
-    """Overlay a format's fields onto the user's global settings.
-
-    Only fields the format actually sets are overlaid; everything else keeps the
-    global value.  The input settings are not modified.
-    """
-    out = copy.deepcopy(settings)
-    if fmt.get("template") is not None:
-        out["template"] = fmt["template"]
-    meta = dict(out.get("meta") or {})
-    for field in META_FIELDS:
-        value = (fmt.get("meta") or {}).get(field)
-        if value is not None:
-            meta[field] = value
-    out["meta"] = meta
-    if fmt.get("keep_audio") is not None:
-        out["keep_audio"] = list(fmt["keep_audio"])
-    if fmt.get("keep_subtitle") is not None:
-        out["keep_subtitle"] = list(fmt["keep_subtitle"])
-    return out
-
-
-def resolve_thumbnail(fmt: Dict[str, Any], global_thumb: Optional[bytes]) -> Tuple[str, Optional[bytes]]:
-    """Work out which thumbnail a format sends, as ``(mode, bytes)``.
-
-    * ``"auto"``   — inherit the user's global thumbnail; a frame of the video
-      stands in when there is none
-    * ``"custom"`` — the format's own image
-    * ``"none"``   — no thumbnail at all, and never a video frame
-    """
-    thumb = fmt.get("thumb")
-    if thumb is None:
-        return "auto", global_thumb
-    if not thumb:
-        return "none", None
-    return "custom", bytes(thumb)
-
-
-async def apply_format_field(db: Database, uid: int, fmt_id: int, kind: str, text: str) -> Tuple[bool, str]:
-    """Validate and store one format field.  Returns ``(ok, html_message)``."""
-    text = (text or "").strip()
-    if await db.get_format(uid, fmt_id) is None:
-        return False, "❌ That format is gone."
-
-    if kind == "fmt_name":
-        if not text or _is_clear(text):
-            return False, "❌ Send a name for the format."
-        if len(text) > 60:
-            return False, "❌ That name is too long (60 characters max)."
-        if not await db.update_format(uid, fmt_id, name=text):
-            return False, "❌ You already have a format with that name."
-        return True, f"✅ Renamed to <code>{esc(clip(text, 40))}</code>."
-
-    if kind == "fmt_template":
-        if _is_default(text) or _is_clear(text):
-            await db.update_format(uid, fmt_id, template=None)
-            return True, "✅ Template back to my default."
-        if not text:
-            return False, "❌ The template can't be empty. Send <code>default</code> to use my default."
-        if len(text) > MAX_TEMPLATE_LEN:
-            return False, f"❌ That template is too long ({MAX_TEMPLATE_LEN} characters max)."
-        await db.update_format(uid, fmt_id, template=text)
-        return True, "✅ Template saved.\n" + preview_template(text)
-
-    if kind in META_KINDS:
-        field = META_KINDS[kind]
-        if _is_default(text):
-            await db.update_format(uid, fmt_id, meta={field: None})
-            return True, f"✅ {field.title()} back to your default."
-        if not text:
-            return False, "❌ Send a value, <code>off</code> to clear it, or <code>default</code> for mine."
-        value = "" if _is_clear(text) else text
-        if len(value) > MAX_META_LEN:
-            return False, f"❌ That's too long ({MAX_META_LEN} characters max)."
-        await db.update_format(uid, fmt_id, meta={field: value})
-        if not value:
-            return True, f"✅ {field.title()} cleared for this format."
-        return True, f"✅ {field.title()} set to <code>{esc(clip(value, 80))}</code>."
-
-    if kind in KEEP_KINDS:
-        label = "Keep Audio" if kind == "fmt_keep_audio" else "Keep Subtitle"
-        key = KEEP_KINDS[kind]
-        if _is_default(text):
-            await db.update_format(uid, fmt_id, **{key: None})
-            return True, f"✅ {label} back to your default."
-        if _is_clear(text):
-            await db.update_format(uid, fmt_id, **{key: []})
-            return True, f"✅ {label}: keep every track."
-        tokens: List[str] = parse_track_tokens(text)
-        problem = validate_track_tokens(tokens)
-        if problem:
-            return False, "❌ " + esc(problem)
-        if len(tokens) > MAX_TRACKS:
-            return False, f"❌ That's too many tracks ({MAX_TRACKS} max)."
-        await db.update_format(uid, fmt_id, **{key: tokens})
-        return True, f"✅ {label}: {esc(fmt_tokens(tokens))}"
-
-    raise ValueError(f"unknown format field kind {kind!r}")

bot/media.py

@@ -391,93 +391,6 @@ async def make_video_thumbnail(src: Path, dst: Path, duration: float, cancel: Op
     return code == 0 and dst.exists() and dst.stat().st_size > 0
 
 
-async def probe_full(path: Path | str, cancel: Optional[asyncio.Event] = None) -> Dict[str, Any]:
-    """The raw ffprobe JSON: format, streams, chapters and programs.
-
-    Unlike :func:`probe` this hands back everything ffprobe found, not a
-    parsed subset — it is used to publish a full media report.
-    """
-    code, out, err = await _run(
-        [
-            "ffprobe", "-v", "quiet", "-print_format", "json",
-            "-show_format", "-show_streams", "-show_chapters", "-show_programs", str(path),
-        ],
-        cancel,
-    )
-    try:
-        data = json.loads(out.decode("utf-8", "replace") or "{}")
-    except ValueError:
-        data = {}
-    return data if isinstance(data, dict) else {}
-
-
-async def extract_frame(src: Path, dst: Path, duration: float, cancel: Optional[asyncio.Event] = None) -> bool:
-    """Grab one frame at ~10% of the duration, at the source width.
-
-    Unlike ``make_video_thumbnail`` this keeps the full width — it is for
-    showing a frame, not for Telegram's 320px preview.  Failure is non-fatal.
-    """
-    seek = 1.0 if duration <= 0 else min(max(duration * 0.1, 0.0), 60.0)
-    cmd = [
-        "ffmpeg", "-hide_banner", "-nostdin", "-y", "-loglevel", "error", "-ss", f"{seek:.2f}", "-i", str(src),
-        "-frames:v", "1", "-q:v", "2", str(dst),
-    ]
-    try:
-        code, _o, _e = await _run(cmd, cancel)
-    except MediaError:
-        return False
-    return code == 0 and dst.exists() and dst.stat().st_size > 0
-
-
-def parse_size(text: str) -> Tuple[Optional[int], Optional[int], Optional[str]]:
-    """``"800"`` -> ``(800, None, None)``; ``"800x450"`` -> ``(800, 450, None)``.
-
-    A bad input gives ``(None, None, "an error message")``.
-    """
-    raw = (text or "").strip().lower().replace("×", "x")
-    bad = "Send a size, like <code>800</code> or <code>800x450</code>."
-    if not raw:
-        return None, None, bad
-    if "x" in raw:
-        parts = raw.split("x")
-        if len(parts) != 2 or not all(part.strip().isdigit() for part in parts):
-            return None, None, bad
-        width, height = int(parts[0]), int(parts[1])
-        if width < 1 or height < 1:
-            return None, None, "The size must be at least 1 pixel."
-        return width, height, None
-    if not raw.isdigit():
-        return None, None, bad
-    width = int(raw)
-    if width < 1:
-        return None, None, "The size must be at least 1 pixel."
-    return width, None, None
-
-
-def resize_image(data: bytes, width: Optional[int] = None, height: Optional[int] = None) -> bytes:
-    """Resize an image and return it as a JPEG.
-
-    With one dimension the aspect ratio is kept; with both the exact size is
-    forced.
-    """
-    from PIL import Image
-
-    resample = Image.Resampling.LANCZOS if hasattr(Image, "Resampling") else Image.LANCZOS
-    with Image.open(io.BytesIO(data)) as img:
-        img = img.convert("RGB")
-        if width and height:
-            img = img.resize((width, height), resample)
-        elif width:
-            ratio = width / max(img.width, 1)
-            img = img.resize((width, max(1, round(img.height * ratio))), resample)
-        elif height:
-            ratio = height / max(img.height, 1)
-            img = img.resize((max(1, round(img.width * ratio)), height), resample)
-        buf = io.BytesIO()
-        img.save(buf, "JPEG", quality=90, optimize=True)
-        return buf.getvalue()
-
-
 def prepare_thumb(data: bytes) -> bytes:
     """Resize/re-encode an image to Telegram's thumbnail limits (<=320px, <=200 KB JPEG)."""
     from PIL import Image

bot/panels.py

@@ -6,12 +6,10 @@ limit because the home banner makes every panel a photo caption.
 """
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+from typing import Any, Dict, Iterable, List, Sequence, Tuple
 
-from .db import MAX_FORMATS
 from .media import LANGUAGES, canonical_lang
-from .parser import Info
-from .utils import clip, esc, to_small_caps
+from .utils import clip, esc
 
 Row = List[Tuple[str, str]]
 Panel = Tuple[str, List[Row]]
@@ -185,134 +183,19 @@ def help_panel() -> Panel:
     text = (
         "<b>How to use</b>\n\n"
         "1. Send a file — I rename it with your template and send it back.\n"
-        "2. <code>/rename</code> — pick one of your saved formats, then send the file.\n"
-        "3. <code>/formats</code> — create, edit and delete your saved formats.\n"
-        "4. <code>/template</code> and <code>/caption</code> — the default naming and caption templates.\n"
-        "5. <code>/mode</code> — read the details from the file name or the caption.\n"
-        "6. <code>/check</code> — reply to a file to see what I read from it.\n"
-        "7. <code>/sequence</code> then <code>/sort</code> — collect files, sort them by episode, get them back in order.\n"
-        "8. <code>/metadata</code>, <code>/keepaudio</code>, <code>/keepsubtitle</code> — tags and track clean-up.\n"
-        "9. <code>/filetype</code> — send as document, video or audio.\n"
-        "10. <code>/ethumb</code> and <code>/resize</code> — thumbnails and images.\n"
-        "11. <code>/speed</code> and <code>/mediainfo</code> — my line speed and a file's media info.\n"
-        "12. <code>/queue</code> and <code>/cancel</code> — manage running jobs.\n\n"
+        "2. <code>/rename New Name</code> — reply to a file for a one-off name.\n"
+        "3. /template and /caption — set the naming and caption templates.\n"
+        "4. /mode — read details from the file name or the caption.\n"
+        "5. /metadata, /keepaudio, /keepsubtitle — tags and track clean-up.\n"
+        "6. /filetype — send as document, video or audio.\n"
+        "7. Send a photo — it becomes your thumbnail.\n"
+        "8. /queue and /cancel — manage running jobs.\n\n"
         "Template variables: <code>{title} {season} {episode} {quality} {year} {codec} {filename} {ext}</code>\n"
         "A [bracket] group is dropped when a variable inside it is empty."
     )
     return text, nav("home")
 
 
-def check_report(file_info: Info, caption_info: Info) -> str:
-    """The ``/check`` body: what the bot extracted from the name and from the caption."""
-
-    def field(label: str, value: str) -> str:
-        return f"\u27a6 {label} \u2b46 {esc(value) if value else 'None'}"
-
-    def section(heading: str, info: Info) -> str:
-        lines = [
-            f"{to_small_caps(heading)}:",
-            field("Title", info.title),
-            field("Season", info.season),
-            field("Episode", info.episode),
-            field("Quality", info.quality),
-        ]
-        if info.year:
-            lines.append(field("Year", info.year))
-        if info.codec:
-            lines.append(field("Codec", info.codec))
-        return "\n".join(lines)
-
-    header = f"{to_small_caps('Your Can Change Mode By')} /mode"
-    return "\n\n".join([header, section("FileName", file_info), section("Caption Mode", caption_info)])
-
-
-def _keep_label(value: Any) -> str:
-    """``None`` (inherit) / ``[]`` (every track) / a list of tokens."""
-    if value is None:
-        return "my default"
-    if not value:
-        return "every track"
-    return esc(fmt_tokens(value))
-
-
-def _thumb_label(value: Any) -> str:
-    if value is None:
-        return "my default"
-    return "none" if not value else "✅ set"
-
-
-def formats_list(formats: Sequence[Dict[str, Any]], *, for_rename: bool) -> Panel:
-    """The saved-format picker (``/rename``) and manager (``/formats``)."""
-    if for_rename:
-        title = "<b>PICK A FORMAT</b>"
-        lead = "Choose the format to use, then send me the file."
-        action = "fm"
-    else:
-        title = "<b>MY FORMATS</b>"
-        lead = "Your saved rename formats. Tap one to edit it."
-        action = "fl"
-
-    if not formats:
-        text = (
-            f"{title}\n\n{lead}\n\n"
-            "You have no saved formats yet — create one first.\n"
-            "A format keeps its own template, thumbnail, metadata and track lists; "
-            "everything else uses your normal settings."
-        )
-        return text, [[("➕ New format", "fnew")]] + nav("home")
-
-    lines = [title, "", lead, ""]
-    rows: List[Row] = []
-    for f in formats:
-        own = " ★" if f.get("template") else ""
-        lines.append(f"{DOT} <b>{esc(f['name'])}</b>{own}")
-        rows.append([(clip(f["name"], 30), f"{action}:{f['id']}")])
-    lines.append("")
-    lines.append("★ = this format has its own template.")
-    if len(formats) < MAX_FORMATS:
-        rows.append([("➕ New format", "fnew")])
-    return "\n".join(lines), rows + nav("home")
-
-
-def format_editor(fmt: Dict[str, Any]) -> Panel:
-    """The editor for one saved format."""
-    fid = fmt["id"]
-    lines = [f"<b>FORMAT · {esc(fmt['name'])}</b>", ""]
-    template = fmt.get("template")
-    lines.append(f"{DOT} <b>Template</b> ▸ {_code(template, 120) if template else 'my default'}")
-    for label, key in (("Title", "title"), ("Author", "author"), ("Artist", "artist"),
-                       ("Audio", "audio"), ("Subtitle", "subtitle"), ("Video", "video")):
-        value = (fmt.get("meta") or {}).get(key)
-        lines.append(f"{DOT} <b>{label}</b> ▸ {_code(value, 60) if value is not None else 'my default'}")
-    lines.append(f"{DOT} <b>Keep Audio</b> ▸ {_keep_label(fmt.get('keep_audio'))}")
-    lines.append(f"{DOT} <b>Keep Subtitle</b> ▸ {_keep_label(fmt.get('keep_subtitle'))}")
-    lines.append(f"{DOT} <b>Thumbnail</b> ▸ {_thumb_label(fmt.get('thumb'))}")
-    rows: List[Row] = [
-        [("📝 Template", f"fset:fmt_template:{fid}"), ("🖼 Thumbnail", f"fthumb:{fid}")],
-        [("🎬 Title", f"fset:fmt_title:{fid}"), ("👤 Author", f"fset:fmt_author:{fid}")],
-        [("🎵 Artist", f"fset:fmt_artist:{fid}"), ("🔊 Audio", f"fset:fmt_audio:{fid}")],
-        [("💬 Subtitle", f"fset:fmt_subtitle:{fid}"), ("🎥 Video", f"fset:fmt_video:{fid}")],
-        [("🔊 Keep Audio", f"fset:fmt_keep_audio:{fid}"), ("💬 Keep Subtitle", f"fset:fmt_keep_subtitle:{fid}")],
-        [("🖼 Use default", f"fthumbdef:{fid}"), ("🚫 No thumbnail", f"fthumbnone:{fid}")],
-        [("✏️ Name", f"frename:{fid}"), ("🗑 Delete", f"fdel:{fid}")],
-    ]
-    return "\n".join(lines), rows + nav("formats")
-
-
-def smedia_panel(kind: Optional[str], has_media: bool) -> Panel:
-    """The owner's panel for the banner shown on ``/start``."""
-    what = {"gif": "a GIF", "image": "an image"}.get(kind or "", "nothing")
-    text = (
-        "<b>🖼 START SCREEN</b>\n\n"
-        f"The banner shown on <code>/start</code> is currently <b>{what}</b>.\n\n"
-        "Pick what you want, then send me the file."
-    )
-    rows: List[Row] = [[("🖼 Image", "smedia:image"), ("🎞 GIF", "smedia:gif")]]
-    if has_media:
-        rows.append([("👁 View", "smedia:view"), ("🗑 Delete", "smedia:del")])
-    return text, rows + nav("home")
-
-
 def admin(owner_id: int, admins: Sequence[int], running: int, waiting: int, log_channel: Any) -> Panel:
     shown = ", ".join(f"<code>{a}</code>" for a in list(admins)[:10]) or "none"
     more = f" (+{len(admins) - 10} more)" if len(admins) > 10 else ""
@@ -378,43 +261,5 @@ def input_prompt(kind: str, back: str) -> Panel:
     return PROMPTS[kind], [[("✖ Cancel", f"in:cancel:{back}")]]
 
 
-FORMAT_PROMPTS: Dict[str, str] = {
-    "fmt_name": (
-        "<b>Send the name for this format.</b>\n\n"
-        "Something you'll recognise later, like <code>One Piece format</code>."
-    ),
-    "fmt_template": (
-        "<b>Send the filename template for this format.</b>\n\n"
-        "Variables: <code>{title} {season} {episode} {quality} {year} {codec} {filename} {ext}</code>\n"
-        "A [bracket] group disappears when a variable inside it is empty.\n\n"
-        "Send <code>default</code> to go back to your normal template."
-    ),
-    "fmt_title": "<b>Send the Title</b> to write into the files' metadata.\nSend <code>off</code> to clear it, or <code>default</code> to use your normal one.",
-    "fmt_author": "<b>Send the Author</b> to write into the files' metadata.\nSend <code>off</code> to clear it, or <code>default</code> to use your normal one.",
-    "fmt_artist": "<b>Send the Artist</b> to write into the files' metadata.\nSend <code>off</code> to clear it, or <code>default</code> to use your normal one.",
-    "fmt_audio": (
-        "<b>Send the title for audio tracks</b>.\n<code>{lang}</code> becomes each track's language, "
-        "e.g. <code>{lang} Audio</code>.\nSend <code>off</code> to clear it, or <code>default</code> to use your normal one."
-    ),
-    "fmt_subtitle": (
-        "<b>Send the title for subtitle tracks</b>.\n<code>{lang}</code> becomes each track's language.\n"
-        "Send <code>off</code> to clear it, or <code>default</code> to use your normal one."
-    ),
-    "fmt_video": "<b>Send the title for the video track</b>.\nSend <code>off</code> to clear it, or <code>default</code> to use your normal one.",
-    "fmt_keep_audio": (
-        "<b>Which audio tracks should this format keep?</b>\n\n"
-        "Send language names (<code>English Japanese</code>) or track numbers (<code>2 1</code>). "
-        "The order you give is the output order; all other tracks are dropped.\n"
-        "Send <code>off</code> to keep every track, or <code>default</code> to use your normal list."
-    ),
-    "fmt_keep_subtitle": (
-        "<b>Which subtitle tracks should this format keep?</b>\n\n"
-        "Send language names (<code>English</code>) or track numbers (<code>2</code>). "
-        "The order you give is the output order; all other tracks are dropped.\n"
-        "Send <code>off</code> to keep every track, or <code>default</code> to use your normal list."
-    ),
-}
-
-
 def known_languages() -> str:
     return ", ".join(sorted(LANGUAGES))

bot/parser.py

@@ -327,24 +327,6 @@ def parse_caption(caption: str) -> Info:
     return first
 
 
-def effective_info(stem: str, caption: str, mode: str) -> Info:
-    """The details a rename would use for this file.
-
-    Caption mode only takes the caption when it yields a structured field; an
-    unstructured caption is discarded and the filename is used unchanged.
-    """
-    info = parse_info(stem)
-    if mode != "caption" or not (caption or "").strip():
-        return info
-    cinfo = parse_caption(caption)
-    if not cinfo.structured:
-        return info
-    for field in ("title", "season", "episode", "quality", "year", "codec"):
-        if not getattr(cinfo, field) and getattr(info, field):
-            setattr(cinfo, field, getattr(info, field))
-    return cinfo
-
-
 # ---------------------------------------------------------------------------
 # templates
 # ---------------------------------------------------------------------------
@@ -446,7 +428,14 @@ def compute_new_name(
     stem, ext = split_ext(original_name)
     if not ext:
         ext = original_ext or ""
-    info = effective_info(stem, caption, mode)
+    info = parse_info(stem)
+    if mode == "caption" and caption.strip():
+        cinfo = parse_caption(caption)
+        if cinfo.structured:
+            for field in ("title", "season", "episode", "quality", "year", "codec"):
+                if not getattr(cinfo, field) and getattr(info, field):
+                    setattr(cinfo, field, getattr(info, field))
+            info = cinfo
     values = build_values(info, stem, ext)
     rendered = render_template(template or DEFAULT_TEMPLATE, values)
     rendered = apply_remove_words(rendered, remove_words)

bot/pipeline.py

@@ -94,7 +94,7 @@ class Renamer:
 
     # ------------------------------------------------------------------
     async def process(self, job: Job) -> None:
-        s = job.settings_override or await self.db.get_settings(job.user_id)
+        s = await self.db.get_settings(job.user_id)
         work = Path(self.cfg.temp_dir) / f"job{job.id}"
         work.mkdir(parents=True, exist_ok=True)
         reporter = ProgressReporter(self.client, job.status_msg, job.id, job.new_name, self.cfg.progress_interval)
@@ -178,16 +178,11 @@ class Renamer:
                 )
             )
 
-        if job.thumbnail_mode == "none":
-            thumb = None
-        elif job.thumbnail_mode == "custom":
-            thumb = job.thumbnail
-        else:
-            thumb = job.thumbnail or await self.db.get_thumb(job.user_id)
-            if thumb is None and ext.lower() in media.VIDEO_CONTAINERS and info is not None and info.of("video"):
-                thumb_path = work / "thumb.jpg"
-                if await media.make_video_thumbnail(current, thumb_path, info.duration, job.cancel):
-                    thumb = thumb_path.read_bytes()
+        thumb = await self.db.get_thumb(job.user_id)
+        if thumb is None and ext.lower() in media.VIDEO_CONTAINERS and info is not None and info.of("video"):
+            thumb_path = work / "thumb.jpg"
+            if await media.make_video_thumbnail(current, thumb_path, info.duration, job.cancel):
+                thumb = thumb_path.read_bytes()
 
         # ---- caption ---------------------------------------------------------------------
         parsed = parse_info(split_ext(orig_name)[0])

bot/queue.py

@@ -20,6 +20,7 @@ class Job:
     file_name: str
     size: int
     new_name: str
+    manual: bool = False
     notes: List[str] = field(default_factory=list)  # warnings shown with the queued / finished message
     order: int = 0  # id of the message that triggered the job: files are processed oldest message first
     status_msg: Any = None
@@ -27,12 +28,6 @@ class Job:
     cancel: asyncio.Event = field(default_factory=asyncio.Event)
     created: float = field(default_factory=time.time)
     started: float = 0.0
-    # the settings the name was computed from, so a queued job cannot drift
-    settings_override: Optional[Dict[str, Any]] = None
-    # auto = the user's global thumbnail (a video frame may stand in),
-    # custom = this job's own thumbnail, none = send no thumbnail at all
-    thumbnail_mode: str = "auto"
-    thumbnail: Optional[bytes] = None
 
 
 Runner = Callable[[Job], Awaitable[None]]

bot/sequence.py

@@ -1,100 +0,0 @@
-"""Collecting files and sorting them by episode.
-
-The pure part lives here: which episode each file is, the order they go in,
-and what is missing or repeated.  The Telegram part lives in ``bot/app.py``.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Tuple
-
-from .parser import effective_info, split_ext
-
-
-@dataclass
-class Duplicate:
-    season: str
-    episode: str
-    names: List[str] = field(default_factory=list)
-
-    @property
-    def label(self) -> str:
-        return f"S{self.season}E{self.episode}"
-
-
-@dataclass
-class SortResult:
-    ordered: List[Dict[str, Any]] = field(default_factory=list)
-    missing: List[str] = field(default_factory=list)
-    duplicates: List[Duplicate] = field(default_factory=list)
-    no_episode: List[str] = field(default_factory=list)
-
-
-def detect_episodes(items: List[Dict[str, Any]], mode: str) -> List[Dict[str, Any]]:
-    """Fill in each item's ``season`` and ``episode`` using the mode-aware merge.
-
-    An item is ``{"msg_id": int, "name": str, "caption": str}``; the result adds
-    ``season`` and ``episode`` (empty strings when there are none).
-    """
-    out: List[Dict[str, Any]] = []
-    for item in items:
-        stem, _ext = split_ext(item.get("name") or "")
-        info = effective_info(stem, item.get("caption") or "", mode)
-        entry = dict(item)
-        entry["season"] = info.season
-        entry["episode"] = info.episode
-        out.append(entry)
-    return out
-
-
-def plan_sort(items: List[Dict[str, Any]]) -> SortResult:
-    """Sort the items by season then episode, and find the gaps and the repeats.
-
-    Files with no episode number are kept — they sort last, in the order they
-    arrived, and are reported separately.
-    """
-    numbered = [it for it in items if it.get("episode")]
-    unnumbered = [it for it in items if not it.get("episode")]
-    ordered = sorted(numbered, key=lambda it: (it.get("season") or "", it["episode"])) + unnumbered
-
-    by_season: Dict[str, set] = {}
-    for item in numbered:
-        by_season.setdefault(item.get("season") or "", set()).add(int(item["episode"]))
-
-    missing: List[str] = []
-    for season in sorted(by_season):
-        episodes = by_season[season]
-        for number in range(min(episodes), max(episodes) + 1):
-            if number not in episodes:
-                missing.append(f"S{season}E{number:02d}")
-
-    names: Dict[Tuple[str, str], List[str]] = {}
-    for item in numbered:
-        key = (item.get("season") or "", item["episode"])
-        names.setdefault(key, []).append(item.get("name") or "")
-    duplicates = [
-        Duplicate(season=season, episode=episode, names=files)
-        for (season, episode), files in names.items()
-        if len(files) > 1
-    ]
-
-    return SortResult(
-        ordered=ordered,
-        missing=missing,
-        duplicates=duplicates,
-        no_episode=[item.get("name") or "" for item in unnumbered],
-    )
-
-
-def format_report(result: SortResult, total: int) -> str:
-    """The message shown once the files have been sent back."""
-    lines = [f"✅ Sorted {total} file{'s' if total != 1 else ''}."]
-    if result.missing:
-        lines += ["", "⚠️ Missing: " + ", ".join(result.missing)]
-    if result.duplicates:
-        lines += [""]
-        for duplicate in result.duplicates:
-            lines.append(f"⚠️ Duplicate {duplicate.label}: " + ", ".join(duplicate.names))
-    if result.no_episode:
-        lines += ["", "⚠️ No episode number: " + ", ".join(result.no_episode)]
-    return "\n".join(lines)

bot/speedtest.py

@@ -1,115 +0,0 @@
-"""Internet speed test, using the official Ookla CLI.
-
-The binary is installed in the Docker image (``ookla-speedtest``); see the
-Dockerfile.  Everything here is pure except :func:`run_speedtest`, so the
-parsing and the message can be tested without a network.
-"""
-from __future__ import annotations
-
-import asyncio
-import json
-from dataclasses import dataclass
-
-from .utils import esc
-
-OOKLA_BIN = "ookla-speedtest"
-# --accept-license / --accept-gdpr stop the tool waiting for a prompt; the
-# licence notice goes to stderr, so stdout stays pure JSON.
-OOKLA_ARGS = ("--accept-license", "--accept-gdpr", "--format=json")
-
-
-@dataclass
-class SpeedResult:
-    download_mbps: float = 0.0
-    upload_mbps: float = 0.0
-    ping_ms: float = 0.0
-    server: str = ""
-    isp: str = ""
-
-
-def parse_ookla_json(raw: str) -> SpeedResult:
-    """Read the JSON that ``ookla-speedtest --format=json`` prints.
-
-    The CLI puts its licence notice on stderr, but be forgiving about anything
-    that ends up in front of the JSON.
-    """
-    text = (raw or "").strip()
-    start = text.find("{")
-    if start > 0:
-        text = text[start:]
-    try:
-        data = json.loads(text)
-    except (TypeError, ValueError) as exc:
-        raise ValueError("the speedtest output was not valid JSON") from exc
-    if not isinstance(data, dict):
-        raise ValueError("the speedtest output was not a JSON object")
-    try:
-        download = float(data["download"]["bandwidth"])
-        upload = float(data["upload"]["bandwidth"])
-    except (KeyError, TypeError, ValueError) as exc:
-        raise ValueError("the speedtest output had no download/upload speeds") from exc
-
-    ping = data.get("ping") or {}
-    try:
-        # the CLI reports the round-trip time as "latency"; "iqm" is the
-        # inter-quartile mean it uses for the per-phase numbers
-        ping_ms = float(ping.get("latency") or ping.get("iqm") or 0)
-    except (TypeError, ValueError):
-        ping_ms = 0.0
-
-    server = data.get("server") or {}
-    name = str(server.get("name") or "").strip()
-    location = str(server.get("location") or "").strip()
-    country = str(server.get("country") or "").strip()
-    where = ", ".join(part for part in (location, country) if part)
-    label = " — ".join(part for part in (name, where) if part)
-    return SpeedResult(
-        download_mbps=download / 1_000_000,
-        upload_mbps=upload / 1_000_000,
-        ping_ms=ping_ms,
-        server=label,
-        isp=str(data.get("isp") or "").strip(),
-    )
-
-
-def format_speed(result: SpeedResult) -> str:
-    """The message shown in the chat."""
-    lines = [
-        "<b>📡 Internet speed</b>",
-        "",
-        f"⬇️ Download: <b>{result.download_mbps:.2f} Mbps</b>",
-        f"⬆️ Upload: <b>{result.upload_mbps:.2f} Mbps</b>",
-        f"⏱ Ping: <b>{result.ping_ms:.0f} ms</b>",
-    ]
-    if result.server:
-        lines.append(f"📍 Server: {esc(result.server)}")
-    if result.isp:
-        lines.append(f"🏢 ISP: {esc(result.isp)}")
-    return "\n".join(lines)
-
-
-async def run_speedtest(binary: str = OOKLA_BIN, timeout: float = 180.0) -> SpeedResult:
-    """Run the Ookla CLI and return the result.
-
-    Raises ``FileNotFoundError`` when the binary is missing and
-    ``asyncio.TimeoutError`` when it takes too long.
-    """
-    try:
-        proc = await asyncio.create_subprocess_exec(
-            binary, *OOKLA_ARGS,
-            stdin=asyncio.subprocess.DEVNULL,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-    except FileNotFoundError as exc:
-        raise FileNotFoundError(f"{binary} is not installed") from exc
-    try:
-        out, err = await asyncio.wait_for(proc.communicate(), timeout)
-    except asyncio.TimeoutError:
-        proc.kill()
-        await proc.wait()
-        raise
-    if proc.returncode:
-        detail = (err or b"").decode("utf-8", "replace").strip()[-300:]
-        raise RuntimeError(detail or "the speedtest failed")
-    return parse_ookla_json((out or b"").decode("utf-8", "replace"))

bot/telegraph.py

@@ -1,146 +0,0 @@
-"""Publishing a media-info report to telegra.ph.
-
-No extra dependency: the public Telegraph API is a couple of HTTP calls, so
-``aiohttp`` (already required) is enough.
-"""
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, List, Optional
-
-import aiohttp
-
-from .utils import esc
-
-TELEGRAPH_API = "https://api.telegra.ph"
-AUTHOR_NAME = "Auto Rename Bot"
-SHORT_NAME = "autorename"
-MAX_RAW = 100_000
-
-
-def _tags(raw: Any) -> Dict[str, Any]:
-    tags = raw.get("tags") if isinstance(raw, dict) else None
-    return tags if isinstance(tags, dict) else {}
-
-
-def summary_lines(probe: Dict[str, Any], name: str) -> List[str]:
-    """The plain-text summary: one line per fact."""
-    fmt = probe.get("format") or {}
-    lines = [f"File: {name}"]
-    if fmt.get("format_name"):
-        lines.append(f"Container: {fmt['format_name']}")
-    if fmt.get("duration"):
-        lines.append(f"Duration: {fmt['duration']} s")
-    if fmt.get("size"):
-        lines.append(f"Size: {fmt['size']} bytes")
-    if fmt.get("bit_rate"):
-        lines.append(f"Bit rate: {fmt['bit_rate']}")
-    for key, value in _tags(fmt).items():
-        lines.append(f"{str(key).title()}: {value}")
-    return lines
-
-
-def stream_lines(probe: Dict[str, Any]) -> List[str]:
-    lines: List[str] = []
-    for stream in probe.get("streams") or []:
-        bits = [f"#{stream.get('index')} {stream.get('codec_type') or ''}".strip()]
-        if stream.get("codec_name"):
-            bits.append(str(stream["codec_name"]))
-        if stream.get("width") and stream.get("height"):
-            bits.append(f"{stream['width']}x{stream['height']}")
-        if stream.get("channels"):
-            bits.append(f"{stream['channels']}ch")
-        if stream.get("sample_rate"):
-            bits.append(f"{stream['sample_rate']} Hz")
-        language = _tags(stream).get("language")
-        if language:
-            bits.append(str(language))
-        title = _tags(stream).get("title")
-        if title:
-            bits.append(f"“{title}”")
-        disposition = stream.get("disposition") or {}
-        flags = [name for name in ("default", "forced", "attached_pic") if disposition.get(name)]
-        if flags:
-            bits.append(", ".join(flags))
-        lines.append(" · ".join(bit for bit in bits if bit))
-    return lines
-
-
-def chapter_lines(probe: Dict[str, Any]) -> List[str]:
-    lines: List[str] = []
-    for chapter in probe.get("chapters") or []:
-        title = _tags(chapter).get("title") or "chapter"
-        lines.append(f"{title} — {chapter.get('start_time')} → {chapter.get('end_time')}")
-    return lines
-
-
-def build_summary(probe: Dict[str, Any], name: str) -> str:
-    """A plain-text summary — used as the fallback when telegra.ph is unreachable."""
-    lines = summary_lines(probe, name)
-    streams = stream_lines(probe)
-    if streams:
-        lines += ["", "Streams:"] + streams
-    chapters = chapter_lines(probe)
-    if chapters:
-        lines += ["", "Chapters:"] + chapters
-    return "\n".join(lines)
-
-
-def build_page(probe: Dict[str, Any], name: str) -> str:
-    """The HTML body of the telegra.ph page."""
-    parts = ["<p>" + "<br>".join(esc(line) for line in summary_lines(probe, name)) + "</p>"]
-    streams = stream_lines(probe)
-    if streams:
-        parts.append("<p><b>Streams</b><br>" + "<br>".join(esc(line) for line in streams) + "</p>")
-    chapters = chapter_lines(probe)
-    if chapters:
-        parts.append("<p><b>Chapters</b><br>" + "<br>".join(esc(line) for line in chapters) + "</p>")
-    raw = json.dumps(probe, indent=2, ensure_ascii=False)
-    if len(raw) > MAX_RAW:
-        raw = raw[:MAX_RAW] + "\n… (truncated)"
-    parts.append("<p><b>Raw ffprobe output</b></p>")
-    parts.append(f"<pre><code>{esc(raw)}</code></pre>")
-    return "".join(parts)
-
-
-class Telegraph:
-    """A tiny client for the public telegra.ph API."""
-
-    def __init__(self, token: Optional[str] = None):
-        self.token = token
-
-    async def _post(self, session: aiohttp.ClientSession, method: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        async with session.post(f"{TELEGRAPH_API}/{method}", json=payload) as response:
-            data = await response.json(content_type=None)
-        if not isinstance(data, dict) or not data.get("ok"):
-            error = data.get("error") if isinstance(data, dict) else None
-            raise RuntimeError(error or f"telegra.ph {method} failed")
-        result = data.get("result")
-        return result if isinstance(result, dict) else {}
-
-    async def create_account(self) -> str:
-        """Make a telegra.ph account and return its access token."""
-        async with aiohttp.ClientSession() as session:
-            result = await self._post(
-                session,
-                "createAccount",
-                {"short_name": SHORT_NAME, "author_name": AUTHOR_NAME},
-            )
-        return str(result.get("access_token") or "")
-
-    async def upload_page(self, title: str, content: List[str]) -> str:
-        """Upload a page and return its URL."""
-        if not self.token:
-            raise RuntimeError("no telegra.ph access token")
-        async with aiohttp.ClientSession() as session:
-            result = await self._post(
-                session,
-                "uploadPage",
-                {
-                    "access_token": self.token,
-                    "title": title,
-                    "content": content,
-                    "author_name": AUTHOR_NAME,
-                },
-            )
-        return str(result.get("url") or "")

bot/utils.py

@@ -47,22 +47,3 @@ def progress_bar(fraction: float, width: int = 14) -> str:
 
 def clip(text: str, limit: int) -> str:
     return text if len(text) <= limit else text[: max(0, limit - 1)] + "…"
-
-
-SMALL_CAPS = {
-    "a": "\u1d43", "b": "\u0299", "c": "\u1d04", "d": "\u1d05", "e": "\u1d07",
-    "f": "\ua730", "g": "\u0262", "h": "\u029c", "i": "\u026a", "j": "\u1d0a",
-    "k": "\u1d0b", "l": "\u029f", "m": "\u1d0d", "n": "\u0274", "o": "\u1d0f",
-    "p": "\u1d18", "q": "\u01eb", "r": "\u0280", "s": "\u0073", "t": "\u1d1b",
-    "u": "\u1d1c", "v": "\u1d20", "w": "\u1d21", "x": "\u0078", "y": "\u02bf",
-    "z": "\u1d22",
-}
-SMALL_CAPS.update({ch.upper(): glyph for ch, glyph in list(SMALL_CAPS.items())})
-
-
-def to_small_caps(text: str) -> str:
-    """Map ``text`` to Unicode small capitals (``"Your" -> "\u02bf\u1d0f\u1d1c\u0280"``).
-
-    Both ASCII cases map to the same glyph; unmapped characters pass through.
-    """
-    return "".join(SMALL_CAPS.get(ch, ch) for ch in (text or ""))

docs/superpowers/plans/2026-10-20-media-tools-and-formats.md

@@ -1,1523 +0,0 @@
-# Media Tools & Named Formats Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add saved named rename formats, a collect-and-sort episode flow, a `/check` inspection command, thumbnail extraction and image resizing, an Ookla speed test, a telegra.ph media-info report, and an owner-only `/smedia` command that replaces the `START_IMAGE` environment variable.
-
-**Architecture:** Eight independent subsystems bolted onto the existing Telethon bot. Pure logic (parsing, sorting, small caps, report building, CLI output parsing) lives in new focused modules and is unit-tested without network or Telegram. Telegram-facing behaviour is added to `bot/app.py` as new handlers and to `bot/panels.py` as pure `(text, buttons)` builders, matching the existing pattern. Persistence goes in three new SQLAlchemy tables created by the existing `Base.metadata.create_all` in `Database.init()`.
-
-**Tech Stack:** Python 3.12, Telethon 1.45, SQLAlchemy 2.x (async), ffmpeg/ffprobe, Pillow, aiohttp, pytest + pytest-asyncio.
-
-**Spec:** `docs/superpowers/specs/2026-10-20-media-tools-and-formats-design.md` — the plan argues from the spec, so the spec travels with it; executors read both.
-
-## Global Constraints
-
-- Python 3.12; the project runs on `python:3.12-slim`. No new pip dependency is needed: `aiohttp` (Telegraph), `Pillow` (resize) and `ffmpeg`/`ffprobe` are already present.
-- The Ookla CLI is installed in the Dockerfile, not pip-installed. Version pinned to `ookla-speedtest-1.2.0-linux-x86_64.tgz`.
-- `DATABASE_URL` may be Postgres or SQLite. **Every new primary key column must be `Integer`, not `BigInteger`** — SQLite only auto-increments a column declared exactly `INTEGER PRIMARY KEY`.
-- The existing test suite (266 tests) must keep passing, except the three tests that cover behaviour this work deliberately removes (see Task 4 and Task 10).
-- The bot only reacts in private chats. Unknown users are ignored and reported to the log channel.
-- Every new user-facing string is plain text with Telegram-HTML escaping applied to user-supplied values.
-- Inline-button callback payloads are limited to 64 bytes.
-- `MAX_FORMATS` is 12, per user.
-- A format field is tri-state: `None` = inherit the user's global setting, `""`/`[]` = explicitly empty, a real value = override.
-- The user calls the formats "One Piece format", "Dragon Ball format" — never "Format 1".
-
-## Review Focus
-
-Five failure modes the spec implies that no task's tests would otherwise exercise. Each line gets a test in the task that owns the code.
-
-1. **A format's template must reach the file name.** The name is computed in `App.enqueue`, not in `Renamer.process`; resolving the format only inside the pipeline silently renames every file with the global template. → Task 4.
-2. **A format that explicitly sets "no thumbnail" must send no thumbnail at all** — not the global thumbnail, not an automatic video frame, and never an empty byte string handed to `send_file(thumb=...)`. → Task 4.
-3. **A file with no episode number must survive a sort.** It is not dropped; it sorts last in arrival order and is listed separately in the report. → Task 5.
-4. **An open sequence must suppress auto-rename.** Files sent while a sequence is open are collected, never renamed and re-uploaded. → Task 5.
-5. **A format deleted between enqueue and the run must not break the queued job.** The job carries resolved settings, not a format id. → Task 4.
-
----
-
-### Task 1: Mode-aware info, small caps, and the `/check` report
-
-**Files:**
-- Modify: `bot/parser.py` (add `effective_info`, refactor `compute_new_name` to use it)
-- Modify: `bot/utils.py` (add `to_small_caps`)
-- Modify: `bot/panels.py` (add `check_report`)
-- Create: `tests/test_check.py`
-
-**Interfaces:**
-- Consumes: nothing new. `parser.parse_info`, `parser.parse_caption`, `parser.Info` already exist.
-- Produces:
-  - `parser.effective_info(stem: str, caption: str, mode: str) -> Info` — the details a rename would use. For `mode != "caption"` it returns `parse_info(stem)`. For `mode == "caption"` it parses the caption; if that parse has no structured field (season/episode/quality/year) it returns `parse_info(stem)` unchanged, otherwise the caption's values with the filename filling in only the fields the caption left empty.
-  - `utils.to_small_caps(text: str) -> str` — maps both cases to Unicode small capitals, leaves unmapped characters alone.
-  - `panels.check_report(file_info: Info, caption_info: Info) -> str` — the `/check` message body (HTML-escaped values, no buttons).
-
-- [ ] **Step 1: Write the failing tests**
-
-In `tests/test_check.py`:
-
-```python
-from bot.parser import Info, effective_info
-from bot.panels import check_report
-from bot.utils import to_small_caps
-
-
-def test_to_small_caps_maps_every_letter_and_leaves_the_rest():
-    assert to_small_caps("Your") == "\u02bf\u1d0f\u1d1c\u0280"   # ʏ ᴏ ᴜ ʀ
-    assert to_small_caps("FileName") == to_small_caps("filename")
-    assert to_small_caps("123 /mode!") == "123 /mode!"
-
-
-def test_effective_info_uses_the_caption_only_when_it_is_structured():
-    stem = "Dragon Ball Super Beerus S01E02 1080p"
-    assert effective_info(stem, "", "filename").title == "Dragon Ball Super Beerus"
-    # an unstructured caption is discarded entirely
-    assert effective_info(stem, "My Show", "caption").title == "Dragon Ball Super Beerus"
-    # a structured caption wins, and the filename fills in what it lacks
-    info = effective_info(stem, "Beerus 1080p S01E02", "caption")
-    assert info.season == "01" and info.episode == "02" and info.quality == "1080p"
-
-
-def test_check_report_has_the_agreed_layout():
-    info = Info(title="Dragon Ball Super Beerus", season="01", episode="02", quality="1080p")
-    text = check_report(info, info)
-    assert "\u02bf\u1d0f\u1d1c\u0280" in text                  # ʏ ᴏ ᴜ ʀ — the small-capped header
-    assert "\ua730\u026a\u029f\u1d07\u0274\u1d43\u1d0d\u1d07:" in text   # ꜰɪʟᴇɴᴀᴍᴇ
-    assert "\u27a1 Title \u2986 Dragon Ball Super Beerus" in text
-    assert "\u27a1 Season \u2986 01" in text
-    assert "\u27a1 Episode \u2986 02" in text
-    assert "\u27a1 Quality \u2986 1080p" in text
-    assert text.count("\u27a1") == 8               # four fields in each of the two sections
-    assert "Chapter" not in text
-
-
-def test_check_report_shows_none_for_empty_values_and_extra_fields_only_when_present():
-    text = check_report(Info(title="X"), Info(title="X"))
-    assert "\u27a1 Season \u2986 None" in text
-    assert "Year" not in text and "Codec" not in text
-    text = check_report(Info(title="X", year="2023", codec="HEVC"), Info(title="X"))
-    assert "\u27a1 Year \u2986 2023" in text and "\u27a1 Codec \u2986 HEVC" in text
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_check.py -v`
-Expected: FAIL — `ImportError: cannot import name 'effective_info' from 'bot.parser'`
-
-- [ ] **Step 3: Implement `effective_info` in `bot/parser.py`**
-
-Add after `parse_caption`:
-
-```python
-def effective_info(stem: str, caption: str, mode: str) -> Info:
-    """The details a rename would use for this file.
-
-    Caption mode only takes the caption when it yields a structured field; an
-    unstructured caption is discarded and the filename is used unchanged.
-    """
-    info = parse_info(stem)
-    if mode != "caption" or not (caption or "").strip():
-        return info
-    cinfo = parse_caption(caption)
-    if not cinfo.structured:
-        return info
-    for field in ("title", "season", "episode", "quality", "year", "codec"):
-        if not getattr(cinfo, field) and getattr(info, field):
-            setattr(cinfo, field, getattr(info, field))
-    return cinfo
-```
-
-Refactor `compute_new_name` to call it: replace its inline merge block with
-`info = effective_info(stem, caption, mode)`. The returned name must not change.
-
-- [ ] **Step 4: Implement `to_small_caps` in `bot/utils.py`**
-
-A module-level dict mapping each ASCII letter to its small-capital codepoint, and:
-
-```python
-def to_small_caps(text: str) -> str:
-    """'Your' -> 'Y\u0282\u1d0f\u1d1c'.  Unmapped characters are left alone."""
-    return "".join(SMALL_CAPS.get(ch, ch) for ch in (text or ""))
-```
-
-The mapping table (both cases map to the same glyph):
-
-```
-a \u1d43   b \u0299   c \u1d04   d \u1d05   e \u1d07   f \ua730   g \u0262
-h \u029c   i \u026a   j \u1d0a   k \u1d0b   l \u029f   m \u1d0d   n \u0274
-o \u1d0f   p \u1d18   q \u01eb   r \u0280   s \u0073   t \u1d1b   u \u1d1c
-v \u1d20   w \u1d21   x \u0078   y \u02bf   z \u1d22
-```
-
-- [ ] **Step 5: Implement `check_report` in `bot/panels.py`**
-
-```python
-def check_report(file_info: Info, caption_info: Info) -> str:
-    """The /check body: what the bot extracted from the name and from the caption."""
-```
-
-Structure, exactly:
-
-```
-<smallcaps "Your Can Change Mode By"> /mode
-
-<smallcaps "FileName">:
-➦ Title ⭆ <value>
-➦ Season ⭆ <value>
-➦ Episode ⭆ <value>
-➦ Quality ⭆ <value>
-[➦ Year ⭆ <value>]      only when the parser found one
-[➦ Codec ⭆ <value>]     only when the parser found one
-
-<smallcaps "Caption Mode">:
-➦ ... same fields ...
-```
-
-Field order is Title, Season, Episode, Quality, then Year and Codec when present.
-An empty value renders as `None`. Values are HTML-escaped with `esc` from
-`bot.utils`. The section headings are small-capped; the field names and values are not.
-Import `Info` and `to_small_caps` in `bot/panels.py`.
-
-- [ ] **Step 6: Run the tests to verify they pass**
-
-Run: `pytest tests/test_check.py -v`
-Expected: PASS (4 tests)
-
-- [ ] **Step 7: Run the whole suite to confirm nothing regressed**
-
-Run: `pytest -q`
-Expected: all previously passing tests still pass (266 + 4)
-
-- [ ] **Step 8: Commit**
-
-```bash
-git add bot/parser.py bot/utils.py bot/panels.py tests/test_check.py
-git commit -m "feat: mode-aware info parsing, small caps and the /check report"
-```
-
----
-
-### Task 2: Database tables for formats, sequences and the start banner
-
-**Files:**
-- Modify: `bot/db.py`
-- Modify: `tests/test_db.py`
-
-**Interfaces:**
-- Consumes: nothing new.
-- Produces:
-  - `db.MAX_FORMATS: int` — 12.
-  - Model `Format` with columns `id` (Integer pk), `user_id` (BigInteger, indexed), `name` (String 64), `position` (Integer), `template` (Text, nullable), `thumb` (LargeBinary, nullable), `meta` (Text, JSON), `keep_audio` (Text, nullable), `keep_subtitle` (Text, nullable). Unique on `(user_id, name)`.
-  - Model `SequenceRow` with `user_id` (BigInteger pk), `items` (Text, JSON list), `copied` (Integer), `updated_at` (DateTime).
-  - Model `BotMedia` with `id` (Integer pk), `kind` (String 8), `data` (LargeBinary).
-  - `Database.list_formats(uid) -> List[Dict]`, `get_format(uid, fmt_id) -> Optional[Dict]`,
-    `create_format(uid, name) -> Optional[Dict]` (None when the name is taken or 12 exist),
-    `update_format(uid, fmt_id, **changes) -> bool`, `delete_format(uid, fmt_id) -> bool`,
-    `count_formats(uid) -> int`.
-  - `Database.get_sequence(uid) -> Optional[Dict]` (`{"items": [...], "copied": int}`),
-    `set_sequence(uid, items, copied=0) -> None`, `clear_sequence(uid) -> None`.
-  - `Database.get_start_media() -> Optional[Dict]` (`{"kind": "image"|"gif", "data": bytes}`),
-    `set_start_media(kind, data) -> None`, `clear_start_media() -> None`.
-  - The format dict shape is `{"id": int, "name": str, "template": Optional[str], "thumb": Optional[bytes], "meta": Dict[str, Optional[str]], "keep_audio": Optional[List[str]], "keep_subtitle": Optional[List[str]]}`. `meta` always has the six keys `title, author, artist, audio, subtitle, video`, each `None` (inherit) or a string.
-
-- [ ] **Step 1: Write the failing tests**
-
-Append to `tests/test_db.py`:
-
-```python
-async def test_formats_crud_and_the_twelve_slot_limit(db):
-    assert await db.count_formats(7) == 0
-    first = await db.create_format(7, "One Piece format")
-    assert first["id"] and first["name"] == "One Piece format"
-    assert first["template"] is None and first["keep_audio"] is None
-    assert first["meta"]["title"] is None
-    assert await db.create_format(7, "One Piece format") is None   # the name is taken
-    for i in range(11):
-        assert await db.create_format(7, f"F{i}") is not None
-    assert await db.count_formats(7) == 12
-    assert await db.create_format(7, "Thirteenth") is None          # the limit
-    assert await db.count_formats(8) == 0                         # per user
-    assert [f["name"] for f in await db.list_formats(7)][0] == "One Piece format"
-
-
-async def test_format_fields_round_trip_through_the_database(db):
-    fmt = await db.create_format(7, "Dragon Ball")
-    await db.update_format(7, fmt["id"], template="[S{season}E{episode}] {title}",
-                            meta={"title": "", "author": "Kuririn"},
-                            keep_audio=[], keep_subtitle=["english"])
-    got = await db.get_format(7, fmt["id"])
-    assert got["template"] == "[S{season}E{episode}] {title}"
-    assert got["meta"]["title"] == "" and got["meta"]["author"] == "Kuririn"
-    assert got["meta"]["artist"] is None
-    assert got["keep_audio"] == [] and got["keep_subtitle"] == ["english"]
-    assert await db.get_format(9, fmt["id"]) is None               # another user
-    assert await db.delete_format(7, fmt["id"]) is True
-    assert await db.delete_format(7, fmt["id"]) is False
-
-
-async def test_sequence_and_start_media(db):
-    assert await db.get_sequence(3) is None
-    await db.set_sequence(3, [{"msg_id": 1, "name": "a.mkv", "caption": ""}])
-    seq = await db.get_sequence(3)
-    assert seq["items"][0]["name"] == "a.mkv" and seq["copied"] == 0
-    await db.set_sequence(3, seq["items"], copied=2)
-    assert (await db.get_sequence(3))["copied"] == 2
-    await db.clear_sequence(3)
-    assert await db.get_sequence(3) is None
-
-    assert await db.get_start_media() is None
-    await db.set_start_media("gif", b"\x00gif")
-    assert (await db.get_start_media())["kind"] == "gif"
-    assert (await db.get_start_media())["data"] == b"\x00gif"
-    await db.set_start_media("image", b"\xff\xd8")
-    assert (await db.get_start_media())["kind"] == "image"   # one row, replaced
-    await db.clear_start_media()
-    assert await db.get_start_media() is None
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_db.py -v`
-Expected: FAIL — `AttributeError: 'Database' object has no attribute 'count_formats'`
-
-- [ ] **Step 3: Add the models to `bot/db.py`**
-
-Add `UniqueConstraint` to the sqlalchemy import. Add the three models after `class Admin`. Use
-`mapped_column(Integer, primary_key=True, autoincrement=True)` for `Format.id` and `BotMedia.id`
-— **not** `BigInteger`, because SQLite only auto-increments a column declared exactly
-`INTEGER PRIMARY KEY`. `Format` gets `__table_args__ = (UniqueConstraint("user_id", "name"),)`.
-
-`Format.meta` stores a JSON object; `keep_audio` / `keep_subtitle` store `NULL` for "inherit"
-and a JSON array otherwise, so `NULL` and `[]` stay distinguishable.
-
-- [ ] **Step 4: Add the `Database` methods to `bot/db.py`**
-
-Add `MAX_FORMATS = 12` at module level.
-
-`create_format` must: reject a blank name, reject a name already used by that user, reject the
-call when `count_formats(uid) >= MAX_FORMATS`, and otherwise insert with `position` equal to the
-current count. It returns the created format dict, or `None` on any rejection.
-
-`update_format(uid, fmt_id, **changes)` accepts only the keys `name`, `template`, `thumb`,
-`meta`, `keep_audio`, `keep_subtitle`. It must only touch rows belonging to `uid` and returns
-whether a row was changed. `meta` is merged key by key over the stored dict; `keep_audio` and
-`keep_subtitle` are replaced wholesale and `None` is stored as SQL `NULL`.
-
-Every format read decodes `meta` from JSON (a missing key reads back as `None`) and decodes
-`keep_audio` / `keep_subtitle` from JSON, leaving `None` as `None`.
-
-`get_sequence` returns `None` when there is no row, otherwise `{"items": json.loads(row.items), "copied": row.copied}`.
-`set_sequence` upserts the row for that user. `clear_sequence` deletes the row.
-
-`get_start_media` returns the single row (`id == 1`) as `{"kind": ..., "data": bytes(row.data)}` or `None`.
-`set_start_media` replaces the row (`id == 1`). `clear_start_media` deletes it.
-
-- [ ] **Step 5: Run the tests to verify they pass**
-
-Run: `pytest tests/test_db.py -v`
-Expected: PASS (3 new tests plus the existing ones)
-
-- [ ] **Step 6: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add bot/db.py tests/test_db.py
-git commit -m "feat: database tables for formats, sequences and the start banner"
-```
-
----
-
-### Task 3: Resolving a format into effective settings
-
-**Files:**
-- Create: `bot/formats.py`
-- Create: `tests/test_formats.py`
-
-**Interfaces:**
-- Consumes: `db.get_format` and the format dict shape from Task 2; `db.DEFAULT_SETTINGS` from `bot.db`.
-- Produces:
-  - `formats.MAX_FORMATS: int` — re-exported from `bot.db`.
-  - `formats.META_FIELDS: Tuple[str, ...]` — `("title", "author", "artist", "audio", "subtitle", "video")`.
-  - `formats.resolve_format(fmt: Dict[str, Any], settings: Dict[str, Any]) -> Dict[str, Any]` — a deep copy of `settings` with the format's non-`None` fields overlaid. Overlays `template`, each non-`None` key of `meta`, and `keep_audio` / `keep_subtitle` when they are not `None`.
-  - `formats.resolve_thumbnail(fmt: Dict[str, Any], global_thumb: Optional[bytes]) -> Tuple[Optional[bytes], bool]` — the thumbnail bytes to send and whether an automatic video frame may still be used as a fallback.
-  - `formats.apply_format_field(db, uid, fmt_id, kind, text) -> Tuple[bool, str]` — validates and stores one format field, returning `(ok, html_message)`. Kinds: `fmt_name`, `fmt_template`, `fmt_title`, `fmt_author`, `fmt_artist`, `fmt_audio`, `fmt_subtitle`, `fmt_video`, `fmt_keep_audio`, `fmt_keep_subtitle`.
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `tests/test_formats.py`:
-
-```python
-from bot.db import DEFAULT_SETTINGS
-from bot.formats import apply_format_field, resolve_format, resolve_thumbnail
-
-
-def test_a_format_that_inherits_everything_changes_nothing():
-    fmt = {"template": None, "meta": {f: None for f in ("title", "author", "artist", "audio", "subtitle", "video")},
-           "keep_audio": None, "keep_subtitle": None}
-    settings = dict(DEFAULT_SETTINGS, template="GLOBAL", keep_audio=["english"])
-    assert resolve_format(fmt, settings) == settings
-
-
-def test_a_format_overlays_only_the_fields_it_sets():
-    fmt = {"template": "[S{season}E{episode}] {title}",
-           "meta": {"title": "One Piece", "author": None, "artist": None, "audio": None, "subtitle": None, "video": None},
-           "keep_audio": [], "keep_subtitle": None}
-    settings = dict(DEFAULT_SETTINGS, template="GLOBAL", keep_audio=["english"], keep_subtitle=["japanese"])
-    out = resolve_format(fmt, settings)
-    assert out["template"] == "[S{season}E{episode}] {title}"
-    assert out["meta"]["title"] == "One Piece" and out["meta"]["author"] == ""
-    assert out["keep_audio"] == [] and out["keep_subtitle"] == ["japanese"]   # inherit
-    assert settings["template"] == "GLOBAL"                                   # the input is not mutated
-
-
-def test_resolve_thumbnail_states():
-    inherit = {"thumb": None}
-    custom = {"thumb": b"\xff\xd8jpeg"}
-    none = {"thumb": b""}
-    assert resolve_thumbnail(inherit, b"GLOBAL") == (b"GLOBAL", False)
-    assert resolve_thumbnail(inherit, None) == (None, True)      # a video frame may still be used
-    assert resolve_thumbnail(custom, b"GLOBAL") == (b"\xff\xd8jpeg", False)
-    assert resolve_thumbnail(none, b"GLOBAL") == (None, False)    # explicitly none: never a frame
-
-
-async def test_apply_format_field_clearing_and_inheriting(db):
-    fmt = await db.create_format(1, "One Piece")
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_title", "One Piece")
-    assert ok and "One Piece" in msg
-    ok, _ = await apply_format_field(db, 1, fmt["id"], "fmt_title", "off")
-    assert ok
-    assert (await db.get_format(1, fmt["id"]))["meta"]["title"] == ""      # explicitly empty
-    ok, _ = await apply_format_field(db, 1, fmt["id"], "fmt_keep_audio", "off")
-    assert ok
-    assert (await db.get_format(1, fmt["id"]))["keep_audio"] == []          # keep every track
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_name", "off")
-    assert not ok                                                          # a format must have a name
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_formats.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'bot.formats'`
-
-- [ ] **Step 3: Implement `bot/formats.py`**
-
-`resolve_format` deep-copies `settings` (use `copy.deepcopy`), then applies the overlays. The
-`meta` overlay merges field by field over the copied `settings["meta"]`, keeping the six
-`META_FIELDS` keys.
-
-`resolve_thumbnail` implements the three states exactly as the test pins them:
-a `None` thumb inherits the global thumbnail (and only allows a video frame when there is no
-global thumbnail at all), a non-empty thumb is the custom one, and an empty thumb means
-"no thumbnail at all" — never a video frame.
-
-`apply_format_field` maps each kind onto a storage key:
-
-| kind | stored as | `off` means |
-|---|---|---|
-| `fmt_name` | `name` | rejected — a format must have a name |
-| `fmt_template` | `template` | inherit (`None`) — an empty template is not a valid state |
-| `fmt_title` … `fmt_video` | `meta[<field>]` | explicitly empty (`""`) |
-| `fmt_keep_audio`, `fmt_keep_subtitle` | `keep_audio` / `keep_subtitle` | explicitly empty (`[]`) — keep every track |
-
-Reuse `parse_track_tokens` and `validate_track_tokens` from `bot.media` for the keep lists, and
-`CLEAR_WORDS` from `bot.settings_ops` for the `off` check. The template is validated with the
-same rules the global template uses (non-empty, at most 200 characters).
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pytest tests/test_formats.py -v`
-Expected: PASS (4 tests)
-
-- [ ] **Step 5: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add bot/formats.py tests/test_formats.py
-git commit -m "feat: resolve a saved format into effective settings"
-```
-
----
-
-### Task 4: `/rename` as a format picker, and the format editor
-
-**Files:**
-- Modify: `bot/queue.py` (`Job` gains the override fields)
-- Modify: `bot/pipeline.py` (apply the override; honour the thumbnail state)
-- Modify: `bot/panels.py` (the format list and the format editor panels)
-- Modify: `bot/app.py` (the `/rename` and `/formats` commands, the callbacks, the enqueue path)
-- Modify: `tests/test_app.py` (rewrite the two removed-behaviour tests, add the new ones)
-
-**Interfaces:**
-- Consumes: `db.list_formats` / `get_format` / `create_format` / `update_format` / `delete_format` from Task 2; `formats.resolve_format`, `formats.resolve_thumbnail`, `formats.apply_format_field` from Task 3.
-- Produces:
-  - `queue.Job.thumbnail_mode: str` — `"auto"` (use the global thumbnail), `"custom"` (use `Job.thumbnail`), `"none"` (send no thumbnail at all). Default `"auto"`.
-  - `queue.Job.thumbnail: Optional[bytes]` — the custom thumbnail bytes, used when `thumbnail_mode == "custom"`.
-  - `queue.Job.settings_override: Optional[Dict[str, Any]]` — the already-resolved effective settings.
-  - `panels.formats_list(formats: Sequence[Dict], *, for_rename: bool) -> Panel` — the picker.
-  - `panels.format_editor(fmt: Dict, settings: Dict) -> Panel` — the editor.
-  - `app.App.format_panel(uid: int, fmt_id: int) -> Panel` — loads the format and the global settings and returns the editor panel.
-
-**Callback data** (all under 64 bytes):
-
-| data | meaning |
-|---|---|
-| `fm:<id>` | use this format for the next file |
-| `fl:<id>` | open this format in the editor |
-| `fnew` | create a format (asks for a name) |
-| `fset:<field>:<id>` | ask for a text value for a field |
-| `fdef:<field>:<id>` | set a field back to "inherit my default" |
-| `fthumb:<id>` | ask for a photo (the thumbnail field) |
-| `fthumbdef:<id>` | thumbnail → inherit the global thumbnail |
-| `fthumbnone:<id>` | thumbnail → explicitly no thumbnail |
-| `fdel:<id>` | ask to confirm the delete |
-| `fdelok:<id>` | delete it |
-| `frename:<id>` | ask for a new name |
-
-- [ ] **Step 1: Write the failing tests**
-
-In `tests/test_app.py`, **replace** `test_rename_command_uses_the_given_name_and_keeps_the_extension`
-and `test_rename_usage_messages` with:
-
-```python
-async def test_rename_picks_a_format_then_renames_the_next_file(ctx):
-    ev = await say(ctx, OWNER, "/rename")
-    assert "fmt" not in ev.out[0][0]            # no formats yet
-    assert "fnew" in data_of(ev.out[0][1])      # only "create a format" is offered
-
-    fmt = await ctx.db.create_format(OWNER, "One Piece format")
-    ev = await say(ctx, OWNER, "/rename")
-    assert "One Piece format" in ev.out[0][0]
-    assert f"fm:{fmt['id']}" in data_of(ev.out[0][1])
-
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "rename_format"
-    await send_doc(ctx, OWNER, "[SubsPlease] Tokyo Revengers - 05 (1080p) [ABCD1234].mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == EPISODE_NEW          # the format's template was applied
-    assert OWNER not in ctx.app.pending         # one file per /rename
-```
-
-Add a test that the format's template really reaches the name (Review Focus 1):
-
-```python
-async def test_a_formats_template_reaches_the_file_name(ctx):
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    await ctx.db.update_format(OWNER, fmt["id"], template="TR - {title} - E{episode}")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Tokyo Revengers - 07 (1080p).mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == "TR - Tokyo Revengers - E07.mkv"
-    assert job.settings_override["template"] == "TR - {title} - E{episode}"
-```
-
-Add a test for the thumbnail states (Review Focus 2):
-
-```python
-async def test_a_format_can_suppress_the_thumbnail_entirely(ctx):
-    fmt = await ctx.db.create_format(OWNER, "No Thumb")
-    await ctx.db.update_format(OWNER, fmt["id"], thumb=b"")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Movie.mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.thumbnail_mode == "none" and job.thumbnail is None
-```
-
-Add a test for a deleted format (Review Focus 5):
-
-```python
-async def test_deleting_a_format_does_not_break_a_queued_job(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Temp")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Movie.mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    await ctx.db.delete_format(OWNER, fmt["id"])
-    assert job.settings_override is not None      # the job carries resolved settings, not an id
-```
-
-And the format-editor tests:
-
-```python
-async def test_the_format_editor_saves_every_field(ctx):
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    ev = await click(ctx, OWNER, f"fl:{fmt['id']}")
-    assert "One Piece" in ev.edits[0][0]
-    await click(ctx, OWNER, f"fset:fmt_title:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "fmt_title"
-    await say(ctx, OWNER, "One Piece")
-    got = await ctx.db.get_format(OWNER, fmt["id"])
-    assert got["meta"]["title"] == "One Piece"
-
-    await click(ctx, OWNER, f"fdef:fmt_title:{fmt['id']}")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["meta"]["title"] is None   # inherit
-
-    await click(ctx, OWNER, f"fthumbnone:{fmt['id']}")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["thumb"] == b""
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_app.py -v -k "format or rename"`
-Expected: FAIL — the `/rename` command still expects a name, and `Job` has no `thumbnail_mode`.
-
-- [ ] **Step 3: Add the override fields to `Job` in `bot/queue.py`**
-
-```python
-thumbnail_mode: str = "auto"           # auto | custom | none
-thumbnail: Optional[bytes] = None
-settings_override: Optional[Dict[str, Any]] = None
-```
-
-Remove the `manual: bool = False` field at the same time (see Step 7).
-
-- [ ] **Step 4: Apply the override in `bot/pipeline.py`**
-
-In `Renamer.process`, replace `s = await self.db.get_settings(job.user_id)` with a merge of
-the global settings and `job.settings_override` (the override is already the full effective
-dict, so the merge is a plain replacement when it is not `None`).
-
-In `Renamer._run`, replace the thumbnail block with:
-
-```python
-if job.thumbnail_mode == "none":
-    thumb = None
-elif job.thumbnail_mode == "custom":
-    thumb = job.thumbnail
-else:
-    thumb = await self.db.get_thumb(job.user_id)
-    if thumb is None and ext.lower() in media.VIDEO_CONTAINERS and info is not None and info.of("video"):
-        ...the existing video-frame fallback...
-```
-
-Never pass an empty byte string to `send_file(thumb=...)`.
-
-- [ ] **Step 5: Add the two panels to `bot/panels.py`**
-
-`formats_list(formats, *, for_rename)` — the text names the command (`/rename` or `/formats`)
-and lists one button per format showing its name, with a marker when the format overrides the
-global template. Add a "➕ New format" button (`fnew`) only when `len(formats) < MAX_FORMATS`.
-Add `nav("home")`.
-
-`format_editor(fmt, settings)` — one row per field with buttons `fset:<kind>:<id>` for the
-template, the six metadata fields and the two keep lists; a thumbnail row with `fthumb:<id>`,
-`fthumbdef:<id>` and `fthumbnone:<id>`; a name row (`frename:<id>`) and a delete row
-(`fdel:<id>`). Every field shows its current value, and marks an inherited field as
-"my default" so the tri-state is visible. Back goes to `m:formats`.
-
-- [ ] **Step 6: Add `"formats"` to `PANEL_NAMES` in `bot/app.py`**
-
-`PANEL_NAMES = {"home", "rename", "cap", "meta", "tool", "ftype", "help", "admin", "formats"}`.
-
-- [ ] **Step 7: Add the `/rename` and `/formats` commands to `bot/app.py`**
-
-`cmd_rename(event)`:
-- If the command has an argument, reply
-  "❌ /rename no longer takes a name. Pick a format, then send me the file."
-- Otherwise reply with `panels.formats_list(await self.db.list_formats(uid), for_rename=True)`.
-
-`cmd_formats(event)`: reply with `panels.formats_list(await self.db.list_formats(uid), for_rename=False)`.
-
-`cmd_rename` must be reachable as `/rename` with no argument. The old `/rename <name>` path
-goes away, and with it:
-
-- The `manual` parameter of `App.enqueue` and the `manual=` argument on the `Job` it builds.
-- The `manual` field on `queue.Job`. Update the assertion in `tests/test_app.py` that reads
-  `not job.manual` (the "queued" test) to drop that part — it becomes
-  `assert job.file_name == EPISODE and job.size == 50 * 1024 * 1024 and job.state == "queued"`.
-- The `build_manual_name` import in `bot/app.py`. Keep `parser.build_manual_name` and its
-  tests in `tests/test_parser.py` — it is a small tested public helper, the bot simply
-  stops calling it.
-
-- [ ] **Step 8: Wire the pending state and the callbacks in `bot/app.py`**
-
-`Pending` gains `format_id: Optional[int] = None`. `Pending.kind` gains the value
-`"rename_format"` and the ten `fmt_*` kinds from Task 3. Every format pending uses
-`back="formats"` so the existing `Pending` construction stays valid.
-
-`on_text` branches: when `p.format_id is not None`, call
-`apply_format_field(self.db, uid, p.format_id, p.kind, event.raw_text)` and re-render the
-editor with `await self.format_panel(uid, p.format_id)`; otherwise keep the existing
-`apply_setting` path unchanged.
-
-`on_photo` branches: when the pending kind is `fmt_thumb`, store the prepared photo in the
-format (`update_format(..., thumb=data)`) and re-render the editor; otherwise keep the existing
-global-thumbnail behaviour.
-
-`on_media` branches: when the pending kind is `rename_format`, enqueue the file with that
-format and clear the pending; otherwise enqueue normally.
-
-`on_callback` handles the new callback data. `fm:<id>` sets
-`Pending(kind="rename_format", format_id=id, ...)` and replies
-"Send me the file to rename with **<name>**." `fnew` sets
-`Pending(kind="fmt_name", ...)` and asks for a name. `fset:<field>:<id>` sets the matching
-pending kind. `fdef:<field>:<id>` writes `None` for that field. `fthumbdef:<id>` writes
-`thumb=None`, `fthumbnone:<id>` writes `thumb=b""`. `fdel:<id>` asks for confirmation and
-`fdelok:<id>` deletes and re-renders the list. `frename:<id>` asks for a new name.
-
-Every callback must check that the format belongs to the sender's user id before changing it.
-
-- [ ] **Step 9: Resolve the format at enqueue time in `bot/app.py`**
-
-`App.enqueue` gains a `fmt: Optional[Dict]` parameter. When it is not `None`:
-
-```python
-s = resolve_format(fmt, s)
-thumb_mode, thumb = resolve_thumbnail(fmt, await self.db.get_thumb(uid))
-```
-
-and `compute_new_name` is called with the **resolved** `s["template"]` and `s["mode"]`, and the
-job is created with `settings_override=s`, `thumbnail_mode=thumb_mode` and `thumbnail=thumb`.
-
-This is the step that makes a format's template reach the file name — the name is computed
-here, not in the pipeline.
-
-- [ ] **Step 10: Run the tests to verify they pass**
-
-Run: `pytest tests/test_app.py -v`
-Expected: PASS
-
-- [ ] **Step 11: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 12: Commit**
-
-```bash
-git add bot/queue.py bot/pipeline.py bot/panels.py bot/app.py tests/test_app.py
-git commit -m "feat: named rename formats, the /rename picker and the format editor"
-```
-
----
-
-### Task 5: `/sequence` and `/sort`
-
-**Files:**
-- Create: `bot/sequence.py`
-- Create: `tests/test_sequence.py`
-- Modify: `bot/app.py` (the commands, the collection branch, the copy loop)
-- Modify: `tests/test_app.py` (the handler tests)
-
-**Interfaces:**
-- Consumes: `parser.effective_info` from Task 1; `db.get_sequence` / `set_sequence` / `clear_sequence` from Task 2.
-- Produces:
-  - `sequence.detect_episodes(items: List[Dict[str, Any]], mode: str) -> List[Dict[str, Any]]` — returns the items with `season` and `episode` filled in. Each item is `{"msg_id": int, "name": str, "caption": str, "season": str, "episode": str}`.
-  - `sequence.plan_sort(items: List[Dict[str, Any]]) -> sequence.SortResult` with
-    - `SortResult.ordered: List[Dict[str, Any]]` — the items in sorted order.
-    - `SortResult.missing: List[str]` — e.g. `["S01E03", "S01E07"]`.
-    - `SortResult.duplicates: List[sequence.Duplicate]` — `Duplicate(season, episode, names)`.
-    - `SortResult.no_episode: List[str]` — the file names that carry no episode number.
-  - `sequence.format_report(result: SortResult, total: int) -> str` — the message shown after the sort.
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `tests/test_sequence.py`:
-
-```python
-from bot.sequence import detect_episodes, format_report, plan_sort
-
-
-def items(*names):
-    return [{"msg_id": i, "name": n, "caption": ""} for i, n in enumerate(names)]
-
-
-def test_episodes_are_detected_from_the_file_name():
-    out = detect_episodes(items("Show S01E02.mkv", "Show S01E10.mkv"), "filename")
-    assert [(i["season"], i["episode"]) for i in out] == [("01", "02"), ("01", "10")]
-
-
-def test_sorting_is_by_season_then_episode_ascending():
-    out = plan_sort(detect_episodes(
-        items("S01E10.mkv", "S02E01.mkv", "S01E02.mkv", "S01E03.mkv"), "filename"))
-    assert [i["name"] for i in out.ordered] == ["S01E02.mkv", "S01E03.mkv", "S01E10.mkv", "S02E01.mkv"]
-
-
-def test_missing_episodes_are_reported_per_season():
-    out = plan_sort(detect_episodes(items("S01E01.mkv", "S01E04.mkv", "S02E01.mkv"), "filename"))
-    assert out.missing == ["S01E02", "S01E03"]
-
-
-def test_duplicate_episodes_are_reported_with_their_file_names():
-    out = plan_sort(detect_episodes(items("S01E02.mkv", "S01E02 (copy).mkv", "S01E03.mkv"), "filename"))
-    assert len(out.duplicates) == 1
-    assert out.duplicates[0].episode == "02"
-    assert out.duplicates[0].names == ["S01E02.mkv", "S01E02 (copy).mkv"]
-
-
-def test_a_file_without_an_episode_is_kept_and_reported():
-    out = plan_sort(detect_episodes(items("S01E02.mkv", "bonus.mkv", "extra.mkv"), "filename"))
-    assert [i["name"] for i in out.ordered] == ["S01E02.mkv", "bonus.mkv", "extra.mkv"]
-    assert out.no_episode == ["bonus.mkv", "extra.mkv"]
-
-
-def test_the_report_lists_only_what_is_wrong():
-    out = plan_sort(detect_episodes(items("S01E01.mkv", "S01E03.mkv"), "filename"))
-    text = format_report(out, 2)
-    assert "S01E02" in text and "Duplicates" not in text and "No episode" not in text
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_sequence.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'bot.sequence'`
-
-- [ ] **Step 3: Implement `bot/sequence.py`**
-
-`detect_episodes` calls `effective_info(stem, item["caption"], mode)` for each item, where
-`stem` is the file name without its extension, and fills `season` and `episode` with the
-parsed values (empty strings when there are none).
-
-`plan_sort` sorts with a **stable** sort whose key is `(0, season, episode)` for an item with
-an episode and `(1, "", "")` for one without, so the numbered files come first in season and
-episode order and the unnumbered ones keep their arrival order at the end.
-
-Missing episodes: group the items by season; for each season take the episodes from the
-lowest to the highest present and subtract the ones present. The result is sorted and
-formatted as `S{season}E{episode}`.
-
-Duplicates: count the `(season, episode)` pairs; every pair seen more than once becomes a
-`Duplicate` holding the season, the episode and the file names in arrival order.
-
-`format_report` returns a message with the sorted count first, then the missing list, the
-duplicate list and the no-episode list, omitting any section that is empty.
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pytest tests/test_sequence.py -v`
-Expected: PASS (6 tests)
-
-- [ ] **Step 5: Write the handler tests for the sequence**
-
-In `tests/test_app.py`:
-
-```python
-async def test_an_open_sequence_collects_files_instead_of_renaming_them(ctx):
-    ev = await say(ctx, OWNER, "/sequence")
-    assert "Send me the files" in ev.texts[0]
-    await send_doc(ctx, OWNER, "Show S01E02.mkv")
-    await send_doc(ctx, OWNER, "Show S01E01.mkv")
-    assert not ctx.app.queue.jobs                    # nothing was renamed
-    seq = await ctx.db.get_sequence(OWNER)
-    assert [i["name"] for i in seq["items"]] == ["Show S01E02.mkv", "Show S01E01.mkv"]
-
-
-async def test_sort_copies_the_files_back_in_order(ctx):
-    await say(ctx, OWNER, "/sequence")
-    await send_doc(ctx, OWNER, "Show S01E02.mkv", mid=11)
-    await send_doc(ctx, OWNER, "Show S01E01.mkv", mid=12)
-    await say(ctx, OWNER, "/sort")
-    # the copies are made one at a time, in episode order
-    assert [ids for _to, _from, ids in ctx.client.copies] == [[12], [11]]
-    assert await ctx.db.get_sequence(OWNER) is None    # the sequence closed
-```
-
-`FakeClient` needs a `copies` list and a `forward_messages` method — add to `tests/tgfakes.py`
-(Telethon has no `copy_messages`; the sort uses `forward_messages` with `drop_author=True`,
-which is what drops the "forwarded from" header):
-
-```python
-self.copies: List[tuple] = []   # forward_messages(to, messages, from_peer, **kw)
-
-async def forward_messages(self, to, messages, from_peer=None, **kw):
-    self.copies.append((to, from_peer, list(messages), kw))
-    return [SimpleNamespace(id=4000 + len(self.copies))]
-```
-
-- [ ] **Step 6: Run the handler tests to verify they fail**
-
-Run: `pytest tests/test_app.py -v -k sequence`
-Expected: FAIL — `/sequence` is not a command.
-
-- [ ] **Step 7: Add the commands to `bot/app.py`**
-
-`cmd_sequence(event)`: if a sequence is already open, reply with the count and the
-`/sort` hint; otherwise create an empty sequence and reply "Send me the files to sort.
-When you're done, send /sort." with a "✖ Cancel" button (`sq:cancel`).
-
-`cmd_sort(event)`: if no sequence is open, reply "You have no files to sort." Otherwise:
-
-1. `items = detect_episodes(seq["items"], mode)` where `mode` is the user's current mode.
-2. `result = plan_sort(items)`.
-3. Send the files back **one at a time**, awaiting each one, with a short sleep between
-   them (0.4 s), starting from `seq["copied"]` so a retry resumes. Each one is
-   `await self.client.forward_messages(chat_id, [msg_id], chat_id, drop_author=True)` —
-   Telethon has no true copy, and `drop_author=True` is what removes the "forwarded
-   from" header. `copied` is an index into the **ordered** list, so the ordering must be
-   identical on a retry; it is, as long as the user's mode has not changed since the
-   sort started.
-4. Save the new `copied` count after every copy.
-5. Edit the status message with `format_report(result, len(result.ordered))`.
-6. Clear the sequence.
-
-The original messages are **kept** — never delete them. A copy that raises `FloodWaitError`
-must wait and retry, and a copy that fails for any other reason must stop the loop, report
-how many were copied, and leave the sequence open.
-
-`on_media`: before enqueueing, check `await self.db.get_sequence(uid)`. If a sequence is open,
-collect the file instead of renaming it (Review Focus 4) — append
-`{"msg_id": msg.id, "name": original_name_of(msg), "caption": msg.raw_text or ""}` to the
-sequence's items, save it, and acknowledge with the new count.
-
-The `sq:cancel` callback clears the sequence.
-
-- [ ] **Step 8: Run the handler tests to verify they pass**
-
-Run: `pytest tests/test_app.py -v -k "sequence or sort"`
-Expected: PASS
-
-- [ ] **Step 9: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 10: Commit**
-
-```bash
-git add bot/sequence.py tests/test_sequence.py tests/tgfakes.py bot/app.py tests/test_app.py
-git commit -m "feat: collect files with /sequence and sort them with /sort"
-```
-
----
-
-### Task 6: The `/check` command
-
-**Files:**
-- Modify: `bot/app.py`
-- Modify: `tests/test_app.py`
-
-**Interfaces:**
-- Consumes: `panels.check_report` and `parser.effective_info` from Task 1; `pipeline.original_name_of` and `pipeline.source_ext`.
-- Produces: the `/check` command handler.
-
-- [ ] **Step 1: Write the failing test**
-
-In `tests/test_app.py`:
-
-```python
-async def test_check_reports_what_the_bot_extracted(ctx):
-    reply = document_message("Dragon Ball Super Beerus S01E02 1080p.mkv", mid=40, caption="")
-    ev = await say(ctx, OWNER, "/check", reply=reply)
-    text = ev.texts[0]
-    assert "Title \u2986 Dragon Ball Super Beerus" in text
-    assert "Season \u2986 01" in text and "Episode \u2986 02" in text
-    assert "Quality \u2986 1080p" in text
-    assert text.count("\u27a1") == 8              # the name and the caption sections
-
-
-async def test_check_needs_a_file(ctx):
-    ev = await say(ctx, OWNER, "/check")
-    assert "Reply to a file" in ev.texts[0]
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `pytest tests/test_app.py -v -k check`
-Expected: FAIL — `/check` is not a command.
-
-- [ ] **Step 3: Implement `cmd_check` in `bot/app.py`**
-
-Reply to a file with `/check`:
-
-1. `reply = await event.get_reply_message()`; if it is not a renameable file, reply
-   "Reply to a file with /check to see what I can read from it."
-2. `name = original_name_of(reply)`, `stem, _ext = split_ext(name)`.
-3. `file_info = parse_info(stem)` — the FileName section.
-4. `caption_info = effective_info(stem, reply.raw_text or "", "caption")` — the Caption Mode
-   section, exactly what a rename in caption mode would use.
-5. Reply with `panels.check_report(file_info, caption_info)`.
-
-Import `parse_info`, `split_ext` from `bot.parser` and `check_report` from `bot.panels`.
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `pytest tests/test_app.py -v -k check`
-Expected: PASS
-
-- [ ] **Step 5: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add bot/app.py tests/test_app.py
-git commit -m "feat: the /check command"
-```
-
----
-
-### Task 7: `/ethumb` and `/resize`
-
-**Files:**
-- Modify: `bot/media.py` (add `extract_frame`, `resize_image`, `parse_size`)
-- Modify: `bot/app.py` (the two commands and their callbacks)
-- Modify: `tests/test_media.py` (the media helpers)
-- Modify: `tests/test_app.py` (the handlers)
-- Modify: `tests/tgfakes.py` (the fake client needs to serve a video file)
-
-**Interfaces:**
-- Consumes: `media.probe` for the duration; `media.prepare_thumb` for the Telegram thumbnail limits.
-- Produces:
-  - `media.extract_frame(src: Path, dst: Path, duration: float, cancel=None) -> bool` — grabs one frame at ~10% of the duration at the **source width** (the existing `make_video_thumbnail` scales to 320px; this one does not). Failure is non-fatal and returns `False`.
-  - `media.resize_image(data: bytes, width: Optional[int] = None, height: Optional[int] = None) -> bytes` — resizes an image. With one dimension the aspect ratio is kept; with both the exact size is forced. The result is a JPEG.
-  - `media.parse_size(text: str) -> Tuple[Optional[int], Optional[int], Optional[str]]` — `"800"` gives `(800, None, None)`, `"800x450"` gives `(800, 450, None)`, anything invalid gives `(None, None, "an error message")`.
-
-- [ ] **Step 1: Write the failing tests**
-
-In `tests/test_media.py`:
-
-```python
-def test_parse_size_accepts_a_width_or_an_exact_size():
-    assert media.parse_size("800") == (800, None, None)
-    assert media.parse_size("800x450") == (800, 450, None)
-    assert media.parse_size(" 640 ") == (640, None, None)
-    w, h, err = media.parse_size("huge")
-    assert (w, h) == (None, None) and "number" in err
-
-
-def test_resize_image_keeps_the_aspect_ratio_or_forces_the_exact_size():
-    buf = io.BytesIO()
-    Image.new("RGB", (1000, 500), (10, 20, 30)).save(buf, "PNG")
-    data = buf.getvalue()
-    out = Image.open(io.BytesIO(media.resize_image(data, width=200)))
-    assert out.size == (200, 100)
-    out = Image.open(io.BytesIO(media.resize_image(data, width=200, height=200)))
-    assert out.size == (200, 200)
-```
-
-In `tests/test_app.py`:
-
-```python
-async def test_resize_answers_with_size_buttons(ctx):
-    reply = FakeMessage(mid=60, photo=object())
-    ev = await say(ctx, OWNER, "/resize", reply=reply)
-    assert "rz:320" in data_of(ev.out[0][1]) and "rz:orig" in data_of(ev.out[0][1])
-
-
-async def test_resize_needs_an_image(ctx):
-    ev = await say(ctx, OWNER, "/resize")
-    assert "Reply to an image" in ev.texts[0]
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_media.py tests/test_app.py -v -k "resize or parse_size"`
-Expected: FAIL — `media.parse_size` does not exist.
-
-- [ ] **Step 3: Implement the three helpers in `bot/media.py`**
-
-`parse_size` accepts a bare number or `WIDTHxHEIGHT` (also `WIDTH X HEIGHT` with spaces).
-Anything else returns an error message mentioning that a number was expected.
-
-`resize_image` opens the image with Pillow, converts to RGB, resizes with
-`Image.LANCZOS` (or `Image.Resampling.LANCZOS` on newer Pillow) and saves as a JPEG.
-
-`extract_frame` runs:
-
-```
-ffmpeg -hide_banner -nostdin -y -loglevel error -ss {seek} -i {src} -frames:v 1 -q:v 2 {dst}
-```
-
-where `seek` is `1.0` when the duration is unknown, otherwise
-`min(max(duration * 0.1, 0.0), 60.0)` — the same rule as `make_video_thumbnail`, but without
-the `scale='min(320,iw)':-2` filter, so the frame keeps the source width.
-
-- [ ] **Step 4: Implement `cmd_ethumb` and `cmd_resize` in `bot/app.py`**
-
-`cmd_ethumb(event)`: reply to a file with `/ethumb`. Download it to a temp dir, probe it for
-the duration, call `extract_frame`, and send the JPEG back as a photo with the buttons
-`[("Set as my thumbnail", "eth:set"), ("✖ Close", "x:close")]`. Keep the bytes in
-`self._ethumbs[uid]` so the `eth:set` callback can store them with `db.set_thumb`. If the
-file has no video stream, reply "That file has no video — I can't take a thumbnail from it."
-
-`cmd_resize(event)`: reply to an image with `/resize`. Reply with the buttons
-`[("320", "rz:320"), ("640", "rz:640"), ("1280", "rz:1280"), ("Original", "rz:orig"),
-("Custom", "rz:custom"), ("✖ Close", "x:close")]`.
-
-The `rz:<size>` callback resizes the replied-to image and sends the result back as a photo
-with a "Set as my thumbnail" button (`eth:set`). `rz:orig` sends the image unchanged.
-`rz:custom` asks for a size with a text pending (`kind="resize_size"`) and the next text
-message is parsed with `media.parse_size`; an invalid size is reported and the pending stays.
-
-- [ ] **Step 5: Run the tests to verify they pass**
-
-Run: `pytest tests/test_media.py tests/test_app.py -v -k "resize or ethumb or parse_size"`
-Expected: PASS
-
-- [ ] **Step 6: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add bot/media.py bot/app.py tests/test_media.py tests/test_app.py tests/tgfakes.py
-git commit -m "feat: /ethumb thumbnail extraction and /resize"
-```
-
----
-
-### Task 8: `/speed` with the Ookla CLI
-
-**Files:**
-- Create: `bot/speedtest.py`
-- Create: `tests/test_speedtest.py`
-- Modify: `bot/app.py` (the command)
-- Modify: `Dockerfile` (install the Ookla CLI)
-
-**Interfaces:**
-- Consumes: nothing new.
-- Produces:
-  - `speedtest.SpeedResult` — a dataclass with `download_mbps: float`, `upload_mbps: float`, `ping_ms: float`, `server: str`, `isp: str`.
-  - `speedtest.parse_ookla_json(raw: str) -> SpeedResult` — parses the JSON from `ookla-speedtest --format=json`. Raises `ValueError` on anything it cannot read.
-  - `speedtest.format_speed(result: SpeedResult) -> str` — the message shown in the chat.
-  - `speedtest.run_speedtest(binary: str = "ookla-speedtest", timeout: float = 120.0) -> SpeedResult` — runs the CLI with `--accept-license --accept-gdpr --simple --format=json`. Raises `FileNotFoundError` when the binary is missing and `asyncio.TimeoutError` when it times out.
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `tests/test_speedtest.py`:
-
-```python
-import pytest
-from bot.speedtest import format_speed, parse_ookla_json
-
-RAW = """{"timestamp":"2024-01-01T00:00:00.000Z",
- "download":{"bandwidth":91234567,"bytes":1000,"elapsed":10000},
- "upload":{"bandwidth":4567890,"bytes":1000,"elapsed":10000},
- "ping":{"jitter":2,"iqm":12,"low":10,"high":15},
- "server":{"id":"1","host":"x","name":"Mumbai","country":"IN","sponsor":"ACME","d":0,"latency":12},
- "isp":"Example ISP","result":{"id":"1","url":"http://x","ok":true}}"""
-
-
-def test_parse_ookla_json_reads_the_speeds():
-    r = parse_ookla_json(RAW)
-    assert r.download_mbps == pytest.approx(91.234567, rel=1e-4)
-    assert r.upload_mbps == pytest.approx(4.56789, rel=1e-4)
-    assert r.ping_ms == 12 and r.server == "Mumbai" and r.isp == "Example ISP"
-
-
-def test_parse_ookla_json_rejects_rubbish():
-    with pytest.raises(ValueError):
-        parse_ookla_json("not json")
-    with pytest.raises(ValueError):
-        parse_ookla_json("{}")
-
-
-def test_format_speed_shows_the_numbers():
-    text = format_speed(parse_ookla_json(RAW))
-    assert "91.23" in text and "4.57" in text and "12" in text
-    assert "Mumbai" in text and "Example ISP" in text
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_speedtest.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'bot.speedtest'`
-
-- [ ] **Step 3: Implement `bot/speedtest.py`**
-
-`parse_ookla_json` loads the JSON, reads `download.bandwidth` and `upload.bandwidth`
-(bits per second) and divides by 1_000_000 for Mbps, reads `ping.iqm` for the latency in
-milliseconds, and joins `server.name` with `server.country` for the server label. It raises
-`ValueError` when the JSON is unparsable or when the `download` or `upload` keys are missing.
-
-`run_speedtest` uses `asyncio.create_subprocess_exec` with the argument list
-`[binary, "--accept-license", "--accept-gdpr", "--simple", "--format=json"]`, captures the
-stdout, waits with `asyncio.wait_for(..., timeout)` and parses the result. A non-zero exit
-code raises `RuntimeError` with the tail of stderr.
-
-`format_speed` returns a message with the download speed, the upload speed, the ping, the
-server and the ISP — two decimals on the speeds, the ping as an integer.
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pytest tests/test_speedtest.py -v`
-Expected: PASS (3 tests)
-
-- [ ] **Step 5: Add the command to `bot/app.py`**
-
-`cmd_speed(event)`: reply "Testing your connection…", run `run_speedtest` in a thread
-(`asyncio.to_thread` is not enough because it is async — use `await run_speedtest(...)`),
-then edit the message with `format_speed(result)`. Catch `FileNotFoundError` and reply
-"The speedtest tool is not installed in this container." and `asyncio.TimeoutError` and reply
-"The speed test timed out."
-
-Add `("speed", "Check the bot's internet speed")` to the `COMMANDS` list.
-
-- [ ] **Step 6: Install the Ookla CLI in the `Dockerfile`**
-
-Add `curl` to the existing `apt-get install` line, then add a new `RUN` layer:
-
-```dockerfile
-RUN curl -sSL https://s3.amazonaws.com/ookla.speedtest.net/tools/cli/ookla-speedtest-1.2.0-linux-x86_64.tgz -o /tmp/ookla.tgz \
-    && tar -xzf /tmp/ookla.tgz -C /tmp \
-    && install -m 0755 /tmp/ookla-speedtest /usr/local/bin/ookla-speedtest \
-    && rm -rf /tmp/ookla.tgz /tmp/ookla-speedtest
-```
-
-- [ ] **Step 7: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 8: Commit**
-
-```bash
-git add bot/speedtest.py bot/app.py tests/test_speedtest.py Dockerfile
-git commit -m "feat: /speed using the Ookla CLI"
-```
-
----
-
-### Task 9: `/mediainfo` with a telegra.ph page
-
-**Files:**
-- Create: `bot/telegraph.py`
-- Create: `tests/test_telegraph.py`
-- Modify: `bot/media.py` (add `probe_full`)
-- Modify: `bot/app.py` (the command)
-- Modify: `tests/test_app.py` (the handler)
-
-**Interfaces:**
-- Consumes: `db.kv_get` / `db.kv_set` from Task 2 for the cached access token; `aiohttp` for the HTTP calls.
-- Produces:
-  - `telegraph.TELEGRAPH_API` — `"https://api.telegra.ph"`.
-  - `telegraph.build_page(probe: Dict[str, Any], name: str) -> str` — the HTML body of the page.
-  - `telegraph.Telegraph` — a class with `async def create_account(self) -> str` and `async def upload_page(self, title: str, content: List[str]) -> str` (returns the page URL).
-  - `media.probe_full(path: Path | str, cancel=None) -> Dict[str, Any]` — the raw ffprobe JSON with format, streams, chapters and programs.
-
-- [ ] **Step 1: Write the failing tests**
-
-Create `tests/test_telegraph.py`:
-
-```python
-from bot.telegraph import build_page
-
-PROBE = {
-    "format": {"filename": "movie.mkv", "format_name": "matroska,webm", "duration": "120.0",
-               "size": "1048576", "bit_rate": "8000000",
-               "tags": {"title": "Movie Title"}},
-    "streams": [
-        {"index": 0, "codec_type": "video", "codec_name": "h264", "width": 1920, "height": 1080,
-         "r_frame_rate": "24/1", "bit_rate": "7000000", "disposition": {"default": 1}},
-        {"index": 1, "codec_type": "audio", "codec_name": "aac", "channels": 2, "sample_rate": "48000",
-         "tags": {"language": "eng", "title": "English"}},
-        {"index": 2, "codec_type": "subtitle", "codec_name": "subrip",
-         "tags": {"language": "eng"}},
-    ],
-    "chapters": [{"id": 0, "start_time": "0.0", "end_time": "60.0", "tags": {"title": "Intro"}}],
-}
-
-
-def test_build_page_lists_the_format_the_streams_and_the_chapters():
-    html = build_page(PROBE, "movie.mkv")
-    assert "movie.mkv" in html and "matroska" in html
-    assert "h264" in html and "1920x1080" in html
-    assert "aac" in html and "English" in html
-    assert "subrip" in html
-    assert "Intro" in html
-    assert "Movie Title" in html
-    assert "<pre" in html and "raw" not in html.lower()[:0]   # the raw JSON is included
-
-
-def test_build_page_survives_an_empty_probe():
-    html = build_page({}, "nothing.mkv")
-    assert "nothing.mkv" in html
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_telegraph.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'bot.telegraph'`
-
-- [ ] **Step 3: Implement `bot/telegraph.py`**
-
-`build_page` returns an HTML fragment (Telegraph accepts an array of HTML strings) with:
-
-1. A summary paragraph: the file name, the container, the duration, the size, the bit rate and
-   the format tags.
-2. One paragraph per stream: the index, the type, the codec, the language, the resolution or
-   the channel count, the sample rate, the bit rate, the title and the disposition flags.
-3. A paragraph per chapter.
-4. A `<pre><code>` block with the raw ffprobe JSON, HTML-escaped, truncated to 100 000
-   characters.
-
-Every value that comes from the file must be HTML-escaped.
-
-`Telegraph` uses `aiohttp.ClientSession` to POST to `{TELEGRAPH_API}/createAccount` with
-`{"short_name": "autorename", "author_name": "Auto Rename Bot"}` and then to
-`{TELEGRAPH_API}/uploadPage` with `{"access_token": ..., "title": ..., "content": [...],
-"author_name": ...}`. Both raise `RuntimeError` with the API's `error` field when the response
-is not `ok`.
-
-- [ ] **Step 4: Run the tests to verify they pass**
-
-Run: `pytest tests/test_telegraph.py -v`
-Expected: PASS (2 tests)
-
-- [ ] **Step 5: Add `probe_full` to `bot/media.py`**
-
-```python
-async def probe_full(path: Path | str, cancel: Optional[asyncio.Event] = None) -> Dict[str, Any]:
-    """The raw ffprobe JSON: format, streams, chapters and programs."""
-```
-
-It runs `ffprobe -v quiet -print_format json -show_format -show_streams -show_chapters
--show_programs` and returns the parsed JSON, or `{}` when it cannot be parsed.
-
-- [ ] **Step 6: Add the command to `bot/app.py`**
-
-`cmd_mediainfo(event)`: reply to a file with `/mediainfo`. Download the whole file to a temp
-dir, run `media.probe_full`, build the page, and upload it:
-
-1. Read the access token from `db.kv_get("telegraph_token")`.
-2. If there is no token, call `Telegraph.create_account()`, store it with
-   `db.kv_set("telegraph_token", token)` and use it.
-3. `url = await Telegraph(token).upload_page(title, [build_page(probe, name)])`.
-4. Reply with the link: "📋 <b>Media info:</b> <a href=\"<url>\">open it</a>".
-
-If the upload fails, reply with the readable summary in the chat instead of the link, so the
-command is never a dead end. Clean up the temp dir in a `finally` block.
-
-- [ ] **Step 7: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 8: Commit**
-
-```bash
-git add bot/telegraph.py bot/media.py bot/app.py tests/test_telegraph.py tests/test_app.py
-git commit -m "feat: /mediainfo published to telegra.ph"
-```
-
----
-
-### Task 10: `/smedia` and removing `START_IMAGE`
-
-**Files:**
-- Modify: `bot/config.py` (drop the `start_image` field)
-- Modify: `bot/app.py` (the command, the animation handler, `/start`)
-- Modify: `bot/panels.py` (the `/smedia` panel)
-- Modify: `.env.example` (drop `START_IMAGE`)
-- Modify: `tests/test_app.py` (rewrite the start-image test, add the `/smedia` tests)
-- Modify: `tests/test_config.py` if it exists (drop the `START_IMAGE` assertions)
-
-**Interfaces:**
-- Consumes: `db.get_start_media` / `set_start_media` / `clear_start_media` from Task 2.
-- Produces:
-  - `panels.smedia_panel(kind: Optional[str], has_media: bool) -> Panel` — the owner panel.
-  - The `smedia` owner command.
-
-- [ ] **Step 1: Write the failing tests**
-
-In `tests/test_app.py`, **replace** `test_start_image_is_sent_as_a_photo_with_the_panel_as_caption`
-with:
-
-```python
-async def test_start_sends_the_stored_banner(ctx):
-    await ctx.db.set_start_media("image", jpeg())
-    ev = await say(ctx, OWNER, "/start")
-    assert ev.out == []
-    (chat, file, kw), = ctx.client.files
-    assert chat == OWNER and "Auto Rename Bot" in kw["caption"]
-    assert kw["buttons"] and kw["parse_mode"] == "html"
-
-
-async def test_start_falls_back_to_text_when_there_is_no_banner(ctx):
-    ev = await say(ctx, OWNER, "/start")
-    assert "Auto Rename Bot" in ev.texts[0] and ctx.client.files == []
-
-
-async def test_smedia_is_owner_only(ctx):
-    ev = await say(ctx, ADMIN_CFG, "/smedia")
-    assert "owner" in ev.texts[0].lower()
-
-
-async def test_smedia_stores_an_image_and_sends_it_on_start(ctx):
-    ev = await say(ctx, OWNER, "/smedia")
-    assert "smedia:image" in data_of(ev.out[0][1])
-    await click(ctx, OWNER, "smedia:image")
-    assert ctx.app.pending[OWNER].kind == "smedia_image"
-    photo = FakeEvent(OWNER, message=FakeMessage(mid=70, photo=object()), photo_bytes=jpeg())
-    await dispatch(ctx.client, photo)
-    media = await ctx.db.get_start_media()
-    assert media["kind"] == "image" and media["data"]
-```
-
-- [ ] **Step 2: Run the tests to verify they fail**
-
-Run: `pytest tests/test_app.py -v -k "smedia or start"`
-Expected: FAIL — `/smedia` is not a command and `Config` still has `start_image`.
-
-- [ ] **Step 3: Remove `start_image` from `bot/config.py`**
-
-Delete the `start_image: Optional[str]` field from the `Config` dataclass and the
-`start_image=env.get("START_IMAGE", "").strip() or None` argument from `load_config`.
-Delete the `START_IMAGE` lines from `.env.example`.
-
-- [ ] **Step 4: Add the panel and the command to `bot/app.py`**
-
-`panels.smedia_panel(kind, has_media)` — the text explains that the banner is shown on
-`/start` and the rows are `[("🖼 Image", "smedia:image"), ("🎞 GIF", "smedia:gif")]` plus
-`[("👁 View", "smedia:view"), ("🗑 Delete", "smedia:del")]` when a banner is stored.
-
-`cmd_smedia(event)` is **owner-only**: add `"smedia"` to `OWNER_COMMANDS` in `bot/app.py` so
-the existing `_guard` enforces it.
-
-The `smedia:view` callback sends the stored banner back to the owner as a photo (or an
-animation) with a "🗑 Delete" button. The `smedia:del` callback deletes it and re-renders the
-panel. Both must be no-ops (with a toast) when no banner is stored.
-
-- [ ] **Step 5: Implement the `/smedia` flow in `bot/app.py`**
-
-The `smedia:image` callback sets `Pending(kind="smedia_image")`; `smedia:gif` sets
-`Pending(kind="smedia_gif")`. Both ask the owner to send the file.
-
-`on_photo`: when the pending kind is `smedia_image`, store the re-encoded JPEG with
-`db.set_start_media("image", data)` instead of the global thumbnail, and reply "✅ Start
-image saved."
-
-A new `on_animation` handler (registered in `_register`) catches
-`events.NewMessage(incoming=True, func=lambda e: e.is_private and e.message.gif is not None)`.
-When the pending kind is `smedia_gif`, it stores the raw bytes with
-`db.set_start_media("gif", data)`. **A GIF must never be re-encoded** — the bytes are stored
-exactly as they arrived so it still animates.
-
-When the pending kind is `smedia_gif` but the file is not an animation, reply "That's not a
-GIF — send me an animated one." and keep the pending.
-
-`cmd_start`: read `db.get_start_media()`. When there is a banner, send it with
-`self.client.send_file(event.chat_id, io.BytesIO(data), caption=text, buttons=..., parse_mode="html", attributes=attrs)`
-where `attrs` is `[types.DocumentAttributeFilename("start.jpg")]` for an image and
-`[types.DocumentAttributeFilename("start.gif"), types.DocumentAttributeAnimated()]` for a
-GIF. When there is no banner, send the text panel as today.
-
-- [ ] **Step 6: Run the tests to verify they pass**
-
-Run: `pytest tests/test_app.py -v -k "smedia or start"`
-Expected: PASS
-
-- [ ] **Step 7: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes, except any test that still references `cfg.start_image` — search
-for `start_image` and remove those references.
-
-- [ ] **Step 8: Commit**
-
-```bash
-git add bot/config.py bot/app.py bot/panels.py .env.example tests/test_app.py
-git commit -m "feat: /smedia replaces the START_IMAGE environment variable"
-```
-
----
-
-### Task 11: Command menu, help panel and README
-
-**Files:**
-- Modify: `bot/app.py` (the `COMMANDS` list)
-- Modify: `bot/panels.py` (the help panel)
-- Modify: `README.md`
-
-**Interfaces:**
-- Consumes: everything from Tasks 1–10.
-- Produces: the final command menu and documentation.
-
-- [ ] **Step 1: Update the `COMMANDS` list in `bot/app.py`**
-
-Add these entries to the `COMMANDS` list, keeping the existing ones:
-
-```python
-("rename", "Pick a saved format and rename a file"),
-("formats", "Manage your saved rename formats"),
-("sequence", "Collect files to sort by episode"),
-("sort", "Sort the collected files and send them back"),
-("check", "See what the bot reads from a file"),
-("ethumb", "Extract a thumbnail from a video"),
-("resize", "Resize an image (reply to it)"),
-("speed", "Check the bot's internet speed"),
-("mediainfo", "Full media info of a file, published to telegra.ph"),
-("smedia", "Set the start image or GIF (owner only)"),
-```
-
-Telegram allows at most 100 commands; the list stays well under that.
-
-- [ ] **Step 2: Update the help panel in `bot/panels.py`**
-
-Rewrite `help_panel()` to describe the new flow:
-
-1. Send a file — it is renamed with your template and sent back.
-2. `/rename` — pick one of your saved formats, then send the file.
-3. `/formats` — create, edit and delete your saved formats.
-4. `/template` and `/caption` — the default naming and caption templates.
-5. `/mode` — read the details from the file name or the caption.
-6. `/check` — reply to a file to see what the bot reads from it.
-7. `/sequence` then `/sort` — collect files, sort them by episode, get them back in order.
-8. `/metadata`, `/keepaudio`, `/keepsubtitle` — tags and track clean-up.
-9. `/filetype` — send as document, video or audio.
-10. `/ethumb` and `/resize` — thumbnails and images.
-11. `/speed` and `/mediainfo` — the bot's line speed and a file's media info.
-12. `/queue` and `/cancel` — manage running jobs.
-
-Keep the template-variables line at the bottom.
-
-- [ ] **Step 3: Update the `README.md`**
-
-- The features table: add rows for the saved formats, the sequence sorting, `/check`,
-  `/ethumb`, `/resize`, `/speed`, `/mediainfo` and `/smedia`.
-- The commands table: add the new commands and change the `/rename` row to
-  "Pick a saved format, then send the file".
-- The settings paragraph: remove `START_IMAGE` from the list of environment variables and say
-  the start banner is set with `/smedia`.
-- The test count line: update it to the new number of tests.
-
-- [ ] **Step 4: Run the whole suite**
-
-Run: `pytest -q`
-Expected: everything passes
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add bot/app.py bot/panels.py README.md
-git commit -m "docs: document the new commands and the format workflow"
-```
-
----
-
-## Self-review
-
-**Spec coverage.** Every section of the spec maps to a task: the format storage and the
-tri-state → Task 2 and Task 3; the picker, the editor and the enqueue-time overlay → Task 4;
-`/sequence` and `/sort` → Task 5; `/check` and the small caps → Task 1 and Task 6;
-`/ethumb` and `/resize` → Task 7; `/speed` and the Ookla install → Task 8; `/mediainfo` and
-Telegraph → Task 9; `/smedia` and the removal of `START_IMAGE` → Task 10; the command menu
-and the documentation → Task 11.
-
-**Step scan.** Every step names a file, a signature or a test, and an exact expectation.
-The code blocks that remain are the ones the tests do not fully determine: the small-caps
-table, the sort key, the Ookla argument list, the callback data scheme and the Dockerfile
-layer.
-
-**Type consistency.** `effective_info` is defined in Task 1 and consumed in Tasks 5 and 6.
-The format dict shape is defined in Task 2 and used by Tasks 3, 4 and 8. `resolve_format`
-and `resolve_thumbnail` are defined in Task 3 and used by Task 4. `plan_sort` and
-`detect_episodes` are defined in Task 5 and used by Task 5's handler. `Job.thumbnail_mode`,
-`Job.thumbnail` and `Job.settings_override` are defined in Task 4 and read in Task 4's
-pipeline change.
-
-**Review Focus.** All five lines are pinned by a named test: the format template reaching
-the name (Task 4, `test_a_formats_template_reaches_the_file_name`), the explicitly-empty
-thumbnail (Task 4, `test_a_format_can_suppress_the_thumbnail_entirely`), the file with no
-episode surviving a sort (Task 5, `test_a_file_without_an_episode_is_kept_and_reported`),
-the open sequence suppressing auto-rename (Task 5,
-`test_an_open_sequence_collects_files_instead_of_renaming_them`), and the deleted format not
-breaking a queued job (Task 4, `test_deleting_a_format_does_not_break_a_queued_job`).

docs/superpowers/specs/2026-10-20-media-tools-and-formats-design.md

@@ -1,522 +0,0 @@
-# Media Tools & Named Formats — Design
-
-Date: 2026-10-20
-Project: `autorename-bot` (Telegram auto-rename bot, Python + Telethon + ffmpeg)
-
-## Intent and the why
-
-The bot has grown into a personal toolbelt for a channel admin who renames, tags and
-repackages a lot of media. Three things are in the way:
-
-1. **One global template.** Every file is renamed with a single template, so a One Piece
-   batch and a Dragon Ball batch cannot be named differently without editing the setting
-   mid-run and losing the previous one.
-2. **No way to reorder a batch.** When a season arrives as 25 separate files, there is no
-   way to see that episode 7 is missing, that episode 12 arrived twice, or to get the
-   files back in episode order.
-3. **The command set is thin.** There is no way to ask what the bot actually extracted
-   from a file, no way to pull a thumbnail out of a video, no way to resize an image, no
-   way to see the bot's line speed, and no way to inspect a file's real media properties.
-   The start banner is baked into an environment variable, which means changing it means
-   redeploying.
-
-This design adds a saved-format system, a collect-and-sort flow, an inspection command,
-and four small media tools, and moves the start banner into the database behind an
-owner-only command.
-
-## Goals
-
-- Save up to 12 **named** formats per user, each carrying its own template, thumbnail,
-  title, author, artist, audio, subtitle, video, keep-audio and keep-subtitle.
-- `/rename` asks which format to use, then asks for the file, then renames it.
-- Collect files, sort them by episode ascending, and report missing and duplicate
-  episodes.
-- Show exactly what the bot can extract from a file's name and from its caption.
-- Extract a thumbnail from a video, and resize an image.
-- Report the bot's internet speed with the Ookla CLI.
-- Publish a full media-info report to telegra.ph and return the link.
-- Replace the `START_IMAGE` environment variable with an owner-only `/smedia` command
-  that accepts an image **or** a GIF.
-
-## Non-goals
-
-- Batch renaming many files in one command. `/rename` handles exactly one file per
-  invocation.
-- Reordering the saved formats in the list. They keep creation order.
-- Re-encoding video. Every existing rename path stays stream-copy.
-- Any kind of "forwarded from" attribution on sorted output — copies, not forwards.
-- Multi-user or shared formats. Each allowed user has their own 12.
-
-## Anti-goals
-
-The change must not slow down or destabilise the existing rename path. Anything that
-touches the hot path (download → probe → ffmpeg → upload) is additive: the format
-system plugs into it as an override, it does not replace it.
-
-## Decisions already made (by the bot owner)
-
-| Area | Decision |
-|---|---|
-| `/check` fields | Title, Season, Episode, Quality. **No chapter field.** |
-| `/rename` | One file per invocation. After it renames, you start over with `/rename`. |
-| `/rename <text>` | **Removed.** `/rename` is now only the format picker. |
-| `/speed` | The **Ookla** CLI (`ookla-speedtest`), not the old `speedtest-cli` package. |
-| `/sort` output | The **actual files** are re-sent in sorted order. |
-| `/sort` mechanism | **Sent back with no "forwarded from" header**, one at a time so the order is exact. |
-| `/sort` originals | The original messages are **kept** in the chat. |
-| Format manager | **Button-driven**, not command-driven. |
-| Format scope | **Per-user**, 12 slots each. |
-| `/resize` input | **Reply to** an image. |
-| Formats are named | e.g. "One Piece format", "Dragon Ball format" — not "Format 1". |
-| `/rename` with no formats | Only "➕ New format" is offered. There is no global-template shortcut. |
-| `/check` caption section | Shows exactly what caption mode would produce, not a field-wise merge. |
-
-## How it is made
-
-### 1. Saved formats
-
-**Storage.** A new `formats` table — not the `users.settings` JSON blob, because each
-format carries a thumbnail (binary) and a thumbnail does not belong in a JSON column.
-
-```
-formats
-  id            integer primary key autoincrement
-  user_id       bigint  index, not null
-  name          varchar(64)  not null
-  position      integer  not null          -- creation order, 0..11
-  template      text     null              -- null = inherit the user's global template
-  thumb         bytea    null              -- null = inherit, empty = no thumbnail, bytes = custom
-  meta          text     not null          -- JSON: {"title": null|"", "author": null|"", ...}
-  keep_audio    text     null              -- null = inherit, [] = keep all, ["english"] = only that
-  keep_subtitle text     null              -- same tri-state
-  unique (user_id, name)
-```
-
-`id` is `INTEGER PRIMARY KEY`, not `BIGINT`: the default database and the whole test
-suite run on SQLite, and SQLite only auto-increments a column declared exactly
-`INTEGER PRIMARY KEY`. SQLAlchemy renders `BigInteger` as `BIGINT`, so an insert
-without an explicit id would fail on SQLite. Use `Integer` for the primary key, or
-`BigInteger().with_variant(Integer, "sqlite")`.
-
-**The tri-state.** Every format field has three possible states, and the distinction
-matters:
-
-- `null` — **inherit**: use the user's global setting for that field.
-- `""` / `[]` — **explicitly empty**: override the global setting with "nothing".
-  This is how a format says "keep every track" (`keep_audio = []`) even when the
-  user's global keep-audio list is `["english"]`.
-- a real value — **override**.
-
-Without the tri-state there is no way to say "this format keeps all tracks" when the
-global list is non-empty, and no way to say "this format has no title" when the global
-title is set.
-
-**Two fields are not tri-state, for good reason:**
-
-- The **template** is inherit-or-value only. An empty template is not a useful state:
-  the global template rejects an empty value, and an empty template would render to
-  nothing, leaving the file with its original name. The editor offers "use my default
-  template" and a real template — never "no template".
-- The **thumbnail** is a genuine tri-state, because the thumbnail is not a settings
-  field at all (it lives in `users.thumb`, not in the settings JSON). See below.
-
-**Applying a format.** The effective settings for a job are the user's global settings
-with the format's non-`null` fields overlaid on top.
-
-This overlay has to happen in **two** places, not one, and the file name is the reason
-the design originally got this wrong:
-
-- `App.enqueue` computes the new file name with `compute_new_name(...)` from the
-  **global** settings, and puts the result in `Job.new_name`.
-- `Renamer.process` reads the settings again, but only for the metadata / track / file
-  type / caption work — it never recomputes the name. It uploads `job.new_name` as it
-  stands.
-
-So a format's template would never reach the file name if the overlay only happened
-inside `process()`. The overlay must be resolved **at enqueue time**, where the name is
-computed, and the resolved result travels on the job:
-
-- `Job` gains `settings_override: Optional[Dict[str, Any]]` — the **already-resolved**
-  effective settings, not a `format_id`.
-- `App.enqueue` resolves the format into an effective settings dict, computes the new
-  name from **that** dict, and stores both on the job.
-- `Renamer.process` becomes `s = merge_settings(global_settings, job.settings_override)`
-  before it does anything else.
-
-Resolving at enqueue time also means a format deleted between enqueue and run cannot
-break a job already in the queue.
-
-**The thumbnail is resolved separately.** The global thumbnail is a blob in
-`users.thumb`, not a settings key, so `merge_settings` cannot carry it. The effective
-thumbnail is resolved on its own and passed to the pipeline alongside the settings
-override. Its three states:
-
-| State | Meaning | Sent with the file |
-|---|---|---|
-| inherit | use the user's global thumbnail | the global thumbnail; if there is none, a frame of the video |
-| custom | this format has its own poster | the format's image |
-| explicitly empty | no thumbnail at all | **nothing** — not even an automatic video frame |
-
-"Explicitly empty" therefore has to suppress the pipeline's existing video-frame
-fallback, and an empty byte string must never be handed to `send_file(thumb=...)`.
-This is a real change to the thumbnail block in `pipeline._run`, and getting it wrong
-silently changes the preview image on every renamed file.
-
-Fields a format does **not** carry fall back to the global settings: mode
-(filename/caption), file type, caption template, remove-words, target channel, and the
-metadata on/off switch.
-
-**Flow.**
-
-- `/formats` → a panel listing the user's formats as buttons (name, with a marker if the
-  format overrides the global template), plus "➕ New format" when there is room, plus
-  Back/Home.
-- `/rename` → the same list of format buttons. Picking one sets a pending state
-  (`kind="rename_format"`, `format_id=…`) and the bot says "Send me the file to rename
-  with **&lt;name&gt;**." The next document the user sends is renamed with that format.
-  The pending state is cleared as soon as that file is queued, so a second file needs a
-  fresh `/rename`.
-- **With no saved formats, `/rename` shows only "➕ New format".** There is no
-  "global template" shortcut and no fallback: renaming goes through a saved format,
-  full stop. The global template is not dead, though — it is the *default a new format
-  starts from*, because a new format's template field begins in the "inherit" state
-  and therefore resolves to the user's global template until they change it.
-- Creating a format: "➕ New format" → the bot asks for a name → the format editor
-  panel opens.
-- The format editor shows one button per field (Template, Thumbnail, Title, Author,
-  Artist, Audio, Subtitle, Video, Keep Audio, Keep Subtitle) plus Rename, Delete and
-  Back. Tapping a field asks for its value as text (or a photo for the thumbnail) and
-  returns to the editor. Every field offers a "clear / use default" option that sets
-  the field to its explicit-empty or inherit state.
-- Deleting asks for confirmation, then removes the row.
-- The 12-slot limit is enforced: the "➕ New format" button is not shown at 12.
-
-**Thumbnail states.** A format's thumbnail is `null` (inherit the user's global
-thumbnail), empty bytes (send no thumbnail) or the stored JPEG. Sending a photo while
-the editor is open on the Thumbnail field sets it. A "use my default" button sets it
-back to `null`, and a "no thumbnail" button sets it to empty.
-
-### 2. `/sequence` and `/sort`
-
-**Flow.**
-
-1. `/sequence` → the bot replies "Send me the files to sort. When you're done, send
-   `/sort`." with a "✖ Cancel" button.
-2. Every file the user sends while a sequence is open is **collected, not renamed**.
-   An open sequence suspends auto-rename for that user. The bot acknowledges each file
-   with a running count.
-3. `/sort` → the bot sorts the collected files, copies them back into the chat in
-   episode order, and reports missing and duplicate episodes.
-4. After a sort the sequence closes. The originals stay in the chat.
-
-**Suspending auto-rename.** Today every incoming document is renamed and re-uploaded
-(`App.on_media` → `App.enqueue`). While a sequence is open for that user, the same
-handler collects the file instead. This is a check at the top of the media handler
-against the open-sequence table — it must not fall through to the rename path.
-
-**Storage.** A `sequences` table so a sequence survives a bot restart (the bot's whole
-premise is that it runs on a free Space where the disk is wiped):
-
-```
-sequences
-  user_id     bigint primary key
-  items       text    not null   -- JSON: [{"msg_id": 12, "name": "ep01.mkv", "caption": "..."}]
-  copied      integer not null   -- how many files were already copied out
-  updated_at  timestamptz
-```
-
-**Episode detection happens at sort time, not at collection time.** The caption is
-needed to merge with the filename in caption mode, so the caption is stored alongside
-the name. The user's mode is read once, when `/sort` runs. This means a mode change
-part-way through a batch applies to the whole batch — which is the sane behaviour —
-rather than producing a half-and-half batch.
-
-**Sorting.** Sort key is `(season, episode)` ascending, both zero-padded strings, so
-`S01E02` sorts before `S01E10`. Files with no episode keep their arrival order and sit
-after every numbered file.
-
-A file whose episode number cannot be found is **not** dropped. It is sorted to the
-end, in the order it was received, and listed separately in the report as "no episode
-number".
-
-**Missing and duplicates.**
-
-- *Missing* — for each season present, the episodes from the lowest to the highest
-  number present, minus the ones actually there. Reported as `S01E03, S01E07`.
-- *Duplicates* — the same `(season, episode)` appearing more than once. Reported with
-  the episode and the file names involved.
-
-Both are reported after the sort finishes, in one message, in this order: how many
-files were sorted, the missing list, the duplicate list, and the files that had no
-episode number. Any of those sections is omitted when empty.
-
-**Copying back.** The files are sent back without a "forwarded from" header. They go
-out **one at a time**, awaiting each one, with a short delay between them, because
-Telegram does not guarantee the order of a batch send. Each one is a `forward_messages`
-call with `drop_author=True` from the chat to itself — Telethon has no true copy, and
-dropping the author is what removes the header. **Telethon has no true copy**
-(that is Bot-API only), so the implementation uses `forward_messages` with
-`drop_author=True`, which drops the attribution and leaves no "forwarded from" header.
-
-The original messages are kept. If a copy fails part-way, the bot says how many were
-copied and leaves the sequence open so the user can retry — and the retry **resumes**
-from where it stopped rather than re-copying the files that already went out. The
-`copied` counter on the sequence row is what makes that possible.
-
-**The report.** Something like:
-
-```
-✅ Sorted 25 files.
-
-⚠️ Missing: S01E03, S01E07
-⚠️ Duplicates: S01E12 (episode 12.mkv, episode 12 (copy).mkv)
-⚠️ No episode number: bonus.mkv, extras.mp4
-```
-
-### 3. `/check`
-
-Reply to a file with `/check` and the bot shows what it can extract, using the
-small-caps style the owner picked:
-
-```
-Yᴏᴜ Cᴀɴ Cʰᴀɴɢᴇ Mᴏᴅᴇ Bʏ /mode
-
-FɪʟᴇNᴀᴍᴇ:
-➦ Title ⭆ Dragon Ball Super Beerus
-➦ Season ⭆ 01
-➦ Episode ⭆ 02
-➦ Quality ⭆ 1080p
-
-Cᴀᴘᴛɪᴏɴ Mᴏᴅᴇ:
-➦ Title ⭆ Dragon Ball Super Beerus
-➦ Season ⭆ 01
-➦ Episode ⭆ 02
-➦ Quality ⭆ 1080p
-```
-
-- The **FileName** section is the parse of the file's name.
-- The **Caption Mode** section is **exactly what a rename in caption mode would use**
-  for this file. That is the rule `compute_new_name` already applies, and it is not the
-  same as a plain field-wise merge:
-  - The caption is parsed. If that parse produced any structured field (season,
-    episode, quality or year), the caption's values win and the filename fills in only
-    the fields the caption did not supply.
-  - If the caption produced **no** structured field, the caption is discarded entirely
-    and the filename parse is used unchanged — including its title.
-  So for a file named `ep01.mkv` with the caption "My Show", the Caption Mode section
-  shows the title from the *filename*, not "My Show". That is the point of the command:
-  it shows the two modes' real output, so the user can tell whether switching modes
-    would change anything.
-- Section headings are small-capped; the field names (Title, Season, …) and the values
-  are normal.
-- **Year** and **Codec** lines appear only when the parser found them, so a file
-  without them produces exactly the output above.
-
-The mode-aware merge must be one shared helper, used by `/check` and by `/sort`'s
-episode detection, so the two can never disagree with what a rename would do.
-
-**Small caps.** A new helper maps a string to the Unicode small-capital letters and
-leaves anything unmapped alone:
-
-```
-a→ᵃ  b→ʙ  c→ᴄ  d→ᴅ  e→ᴇ  f→ꜰ  g→ɢ  h→ʜ  i→ɪ  j→ᴊ  k→ᴋ  l→ʟ  m→ᴍ
-n→ɴ  o→ᴏ  p→ᴘ  q→ǫ  r→ʀ  s→s   t→ᴛ  u→ᴜ  v→ᴠ  w→ᴡ  x→x  y→ʿ  z→ᴢ
-```
-
-Uppercase letters map to the same glyphs as lowercase, which is what makes
-"Yᴏᴜ" out of "Your". Digits, spaces and punctuation are untouched. The helper is
-pure and unit-tested.
-
-### 4. `/ethumb`
-
-Reply to a video or media file with `/ethumb`:
-
-1. The bot downloads the file to a temp dir.
-2. `ffmpeg` grabs a frame at ~10% of the duration (the same seek point the automatic
-   video thumbnail uses) at the source width, written as a JPEG.
-3. The bot sends the image back as a photo, with a "Set as my thumbnail" button and a
-   "Close" button.
-
-"Set as my thumbnail" stores the image as the user's global thumbnail, resized down to
-Telegram's limits by the existing `media.prepare_thumb` helper. A format's thumbnail
-is set by sending a photo while the format editor is open — `/ethumb` does not edit
-formats.
-
-If the file has no video stream (an audio file, an image), the bot says so rather than
-failing silently.
-
-### 5. `/resize`
-
-Reply to an image with `/resize`:
-
-1. The bot replies with size buttons: **320**, **640**, **1280**, **Original**,
-   **Custom**, plus Close.
-2. Picking a preset resizes immediately. **Custom** asks for a size: a single number is
-   a maximum width and keeps the aspect ratio; `WIDTHxHEIGHT` forces that exact size.
-   (This replaces the "force exact size" toggle discussed earlier — the shape of what
-   you type decides.)
-3. The resized image is sent back as a photo with a "Set as my thumbnail" button.
-
-Resizing re-encodes the image; that is inherent to resizing and is the one place in
-this design where bytes are rewritten. Pillow is already a dependency.
-
-Both `/resize` and `/ethumb` accept an image sent as a photo **or** as a document.
-
-### 6. `/speed`
-
-The Ookla CLI is installed in the Dockerfile and run as a subprocess:
-
-```
-ookla-speedtest --accept-license --accept-gdpr --simple --format=json
-```
-
-- `--accept-license` and `--accept-gdpr` are passed so the tool never blocks on a
-  prompt.
-- `--simple` skips the server scan and latency test, so a run takes ~15–30 seconds
-  instead of a minute.
-- `--format=json` makes the output machine-readable. A pure function parses that JSON
-  into the values shown in the chat, so the parsing is unit-tested without a network.
-
-The bot replies with a "Testing your connection…" message first, then reports download
-speed, upload speed, ping, the test server and the ISP. A timeout of 120 seconds
-applies. If the binary is missing (a local run without the Docker image), the bot says
-so clearly instead of showing a stack trace.
-
-**Dockerfile change.** `python:3.12-slim` has no `curl`, so it is added to the apt
-install line, and the Ookla tarball is unpacked to `/usr/local/bin/ookla-speedtest`:
-
-```dockerfile
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends ffmpeg ca-certificates curl \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN curl -sSL https://s3.amazonaws.com/ookla.speedtest.net/tools/cli/ookla-speedtest-1.2.0-linux-x86_64.tgz -o /tmp/ookla.tgz \
-    && tar -xzf /tmp/ookla.tgz -C /tmp \
-    && install -m 0755 /tmp/ookla-speedtest /usr/local/bin/ookla-speedtest \
-    && rm -rf /tmp/ookla.tgz /tmp/ookla-speedtest
-```
-
-The tarball is x86-64 only, which matches the Space's architecture. The version is
-pinned so a rebuild does not silently change the tool.
-
-### 7. `/mediainfo`
-
-Reply to a file with `/mediainfo`:
-
-1. The bot downloads the file (whole file — the point of this command is complete
-   information) and runs `ffprobe` with `-show_format -show_streams -show_chapters
-   -show_programs`.
-2. The raw JSON and a readable summary are turned into an HTML page.
-3. The page is uploaded to telegra.ph and the bot replies with the link.
-
-**Telegraph.** No new dependency: `aiohttp` is already installed, so a small
-`bot/telegraph.py` posts directly to the public API — `createAccount` to get an access
-token, then `uploadPage`. The access token is cached in the `kv` table so a new
-account is not created for every request. If telegra.ph is unreachable from the host,
-the bot says so and shows the readable summary in the chat instead, so the command is
-never a dead end.
-
-**Page content.** A summary section (container, duration, size, bitrate, tags), a
-stream table (index, type, codec, language, resolution, channels, sample rate, bitrate,
-title, disposition flags), the chapters, and finally the raw ffprobe JSON in a `<pre>`
-block. Raw JSON is truncated if it would exceed roughly 100 KB.
-
-### 8. `/smedia` and removing `START_IMAGE`
-
-`/smedia` is **owner-only** (it joins `addadmin`, `deladmin`, `admins` in
-`OWNER_COMMANDS`).
-
-1. `/smedia` → the bot replies with "🖼 Image" and "🎞 GIF" buttons, plus "👁 View" and
-   "🗑 Delete" for the current banner.
-2. Picking Image or GIF asks the owner to send the file. The next photo, animation or
-   document that arrives is stored.
-3. The banner is stored in a new `bot_media` table (one row):
-
-```
-bot_media
-  id    integer primary key   -- always 1
-  kind  varchar(8)            -- 'image' | 'gif'
-  data  bytea  not null
-```
-
-4. The received file is **validated against the kind that was chosen**: picking GIF
-   and sending a JPEG is rejected with a clear message ("that's a photo — send me an
-   animated GIF"), and the stored `kind` always matches the bytes that were stored. A
-   JPEG stored as `kind='gif'` would be sent back as an animation with a still first
-   frame, so the mismatch is caught rather than accepted.
-5. A photo is re-encoded to JPEG for storage. A GIF's bytes are stored exactly as
-   they were sent, so it still animates.
-6. `/start` sends the stored banner instead of the environment variable. A GIF is sent
-   with `DocumentAttributeAnimated` so Telegram renders it as an animation; an image is
-   sent as a photo.
-
-**Removal.** `START_IMAGE` is deleted from `bot/config.py` (the `Config` dataclass
-field and the `load_config` call), from `.env.example` and from the README. The
-banner now survives a restart because it lives in the database.
-
-## What the builder has to decide, and what is already decided
-
-**Already decided (do not re-litigate):** the flow of every command above, the tri-state
-inheritance model, copy-not-forward for `/sort`, originals kept, per-user formats, the
-12-slot limit, Ookla for `/speed`, no chapter field in `/check`, `/rename <text>`
-removed, `/resize` replies to an image.
-
-**Left to the builder (any sensible choice is fine):**
-
-- The exact layout of the new panels — button order, wording, how the format editor
-  presents a field that is currently inheriting.
-- Where the new code lives: the design names `bot/formats.py`, `bot/sequence.py`,
-  `bot/speedtest.py` and `bot/telegraph.py` as suggestions, not requirements. Keep new
-  pure logic out of `app.py`, which is already 774 lines.
-- Whether the small-caps helper lives in `utils.py` or its own module.
-- The exact wording of every user-facing string, beyond the `/check` layout that is
-  given above.
-- How the `ffmpeg` frame-extraction call is factored — `media.py` already has
-  `make_video_thumbnail`, which grabs a 320px-wide frame; the `/ethumb` version needs
-  the source width, so it is a new function rather than a changed one.
-
-## Constraints
-
-- Telegram: bot uploads cap at 2000 MB (`MAX_FILE_MB`); a chat message is 4096
-  characters; an inline-button callback payload is 64 bytes; inline keyboards carry at
-  most 100 buttons.
-- The bot only reacts in private chats. Unknown users are ignored.
-- The Space is free-tier CPU with 50 GB of scratch disk. `/mediainfo` and `/ethumb`
-  download whole files, so they respect the same size limit as a rename.
-- The existing test suite (266 tests) must keep passing and must not need the network.
-
-## Risks
-
-- **Copying 25 files in order** needs 25 API calls. Telegram may rate-limit; the copy
-  loop must handle `FloodWaitError` by waiting, and must not reorder the output.
-- **telegra.ph** may be blocked or slow from some hosts; the fallback to a chat
-  summary covers it.
-- **Ookla** needs outbound access to the speedtest servers and moves a few tens of
-  megabytes; it is a manual command, never automatic.
-- **A format's thumbnail** is stored per format; 12 formats × a JPEG each is small, but
-  the table is binary and must not be loaded into the settings cache.
-
-## Testing
-
-New tests, no network:
-
-- Format CRUD, the 12-slot limit, name uniqueness, and the tri-state overlay
-  producing the expected effective settings.
-- Sorting: ordering across seasons, zero-padded episode order, missing-episode
-  detection, duplicate detection, and files with no episode number.
-- The small-caps mapping, including the exact `/check` layout.
-- The size parser for `/resize` (`800`, `800x450`, invalid input).
-- The Ookla JSON parser.
-- The Telegraph page builder.
-
-The existing 266 tests must still pass, **except** the ones that cover behaviour this
-design deliberately removes. Those are rewritten to cover the new behaviour:
-
-- `test_rename_command_uses_the_given_name_and_keeps_the_extension` and
-  `test_rename_usage_messages` assert the removed `/rename <text>` flow → rewritten
-  for the format picker.
-- `test_start_image_is_sent_as_a_photo_with_the_panel_as_caption` builds its config
-  with `dataclasses.replace(ctx.cfg, start_image=...)`, which raises `TypeError` once
-  the `Config` field is gone → rewritten for the database-stored banner.
-
-"Still passing" means no regressions outside the deliberately removed features.

tests/conftest.py

@@ -41,17 +41,6 @@ def ffprobe_json(path, *extra):
     return json.loads(out)
 
 
-@pytest.fixture
-async def db(tmp_path):
-    """A fresh SQLite database for the tests that need one."""
-    from bot.db import Database
-
-    database = Database(f"sqlite+aiosqlite:///{tmp_path}/t.db")
-    await database.init()
-    yield database
-    await database.close()
-
-
 @pytest.fixture(scope="session")
 def media_dir(tmp_path_factory):
     d = tmp_path_factory.mktemp("media")

tests/test_app.py

@@ -1,5 +1,6 @@
 """Handler-level tests: real Telethon event builders, fake events and client."""
 import asyncio
+import dataclasses
 import io
 import shutil
 import time
@@ -185,119 +186,16 @@ async def test_start_variants(ctx, text):
     assert (await say(ctx, OWNER, text)).out
 
 
-async def test_start_sends_the_stored_banner(ctx):
-    await ctx.db.set_start_media("image", jpeg())
+async def test_start_image_is_sent_as_a_photo_with_the_panel_as_caption(ctx):
+    ctx.app.cfg = dataclasses.replace(ctx.cfg, start_image="https://example.com/banner.jpg")
     ev = await say(ctx, OWNER, "/start")
     assert ev.out == []
     (chat, file, kw), = ctx.client.files
-    assert chat == OWNER and "Auto Rename Bot" in kw["caption"]
-    assert kw["buttons"] and kw["parse_mode"] == "html"
-
-
-async def test_start_falls_back_to_text_when_there_is_no_banner(ctx):
+    assert (chat, file) == (OWNER, "https://example.com/banner.jpg")
+    assert "Auto Rename Bot" in kw["caption"] and kw["buttons"] and kw["parse_mode"] == "html"
+    ctx.client.fail_send_file = True  # a broken banner must not break /start
     ev = await say(ctx, OWNER, "/start")
-    assert "Auto Rename Bot" in ev.texts[0] and ctx.client.files == []
-
-
-async def test_a_stored_gif_is_sent_as_an_animation(ctx):
-    await ctx.db.set_start_media("gif", b"\x00gif")
-    await say(ctx, OWNER, "/start")
-    (chat, file, kw), = ctx.client.files
-    assert chat == OWNER
-    assert kw.get("force_document") is True
-    names = [getattr(a, "file_name", None) for a in kw.get("attributes") or []]
-    assert "start.gif" in names
-    assert any(type(a).__name__ == "DocumentAttributeAnimated" for a in kw.get("attributes") or [])
-
-
-async def test_a_stored_image_is_sent_as_a_photo(ctx):
-    await ctx.db.set_start_media("image", jpeg())
-    await say(ctx, OWNER, "/start")
-    (chat, file, kw), = ctx.client.files
-    assert kw.get("force_document") is not True    # a photo, not a document
-    assert not kw.get("attributes")
-
-
-async def test_smedia_is_owner_only(ctx):
-    ev = await say(ctx, ADMIN_CFG, "/smedia")
-    assert "owner" in ev.texts[0].lower()
-
-
-async def test_smedia_stores_an_image_and_sends_it_on_start(ctx):
-    ev = await say(ctx, OWNER, "/smedia")
-    assert "smedia:image" in data_of(ev.out[0][1])
-    await click(ctx, OWNER, "smedia:image")
-    assert ctx.app.pending[OWNER].kind == "smedia_image"
-    photo = FakeEvent(OWNER, message=FakeMessage(mid=70, photo=object()), photo_bytes=jpeg())
-    await dispatch(ctx.client, photo)
-    media_row = await ctx.db.get_start_media()
-    assert media_row["kind"] == "image" and media_row["data"]
-
-
-async def test_smedia_stores_a_gif(ctx):
-    await click(ctx, OWNER, "smedia:gif")
-    assert ctx.app.pending[OWNER].kind == "smedia_gif"
-    gif = FakeEvent(OWNER, message=FakeMessage(mid=71, gif=object()), photo_bytes=b"\x00gifdata")
-    await dispatch(ctx.client, gif)
-    media_row = await ctx.db.get_start_media()
-    assert media_row["kind"] == "gif" and media_row["data"] == b"\x00gifdata"
-
-
-async def test_the_start_screen_can_be_viewed_and_deleted(ctx):
-    await ctx.db.set_start_media("image", jpeg())
-    await click(ctx, OWNER, "smedia:view")
-    assert ctx.client.files
-    await click(ctx, OWNER, "smedia:del")
-    assert await ctx.db.get_start_media() is None
-
-
-async def test_a_format_thumbnail_is_set_by_sending_a_photo(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Poster")
-    await click(ctx, OWNER, f"fthumb:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "fmt_thumb"
-    photo = FakeEvent(OWNER, message=FakeMessage(mid=72, photo=object()), photo_bytes=jpeg())
-    await dispatch(ctx.client, photo)
-    stored = await ctx.db.get_format(OWNER, fmt["id"])
-    assert stored["thumb"]                       # a JPEG was stored
-    assert OWNER not in ctx.app.pending
-
-
-async def test_renaming_a_format(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Old Name")
-    await click(ctx, OWNER, f"frename:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "fmt_name"
-    await say(ctx, OWNER, "New Name")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["name"] == "New Name"
-
-
-async def test_the_delete_asks_first(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Doomed")
-    cb = await click(ctx, OWNER, f"fdel:{fmt['id']}")
-    assert "Delete" in cb.edits[0][0]
-    assert await ctx.db.get_format(OWNER, fmt["id"]) is not None   # not gone yet
-    await click(ctx, OWNER, f"fdelok:{fmt['id']}")
-    assert await ctx.db.get_format(OWNER, fmt["id"]) is None
-
-
-async def test_speed_reports_a_missing_tool(ctx, monkeypatch):
-    async def missing(*_a, **_kw):
-        raise FileNotFoundError("ookla-speedtest is not installed")
-
-    monkeypatch.setattr(appmod, "run_speedtest", missing)
-    await say(ctx, OWNER, "/speed")
-    assert "installed" in str(ctx.client.edited)
-
-
-async def test_mediainfo_needs_a_file(ctx):
-    ev = await say(ctx, OWNER, "/mediainfo")
-    assert "Reply to a file" in ev.texts[0]
-
-
-async def test_every_new_command_is_registered(ctx):
-    for command in ("rename", "formats", "sequence", "sort", "check", "ethumb", "resize", "speed",
-                    "mediainfo", "smedia"):
-        assert command in [name for name, _d in COMMANDS], command
-        assert (await say(ctx, OWNER, f"/{command}")).out or command == "smedia"
+    assert "Auto Rename Bot" in ev.texts[0]
 
 
 async def test_start_and_help(ctx):
@@ -472,7 +370,7 @@ async def test_a_file_is_queued_with_the_template_name_and_a_cancel_button(ctx):
     ev = await send_doc(ctx, OWNER, mid=10)
     (job,) = ctx.app.queue.jobs.values()
     assert job.new_name == EPISODE_NEW and (job.user_id, job.chat_id, job.msg_id) == (OWNER, OWNER, 10)
-    assert job.file_name == EPISODE and job.size == 50 * 1024 * 1024 and job.state == "queued"
+    assert job.file_name == EPISODE and job.size == 50 * 1024 * 1024 and not job.manual and job.state == "queued"
     text, buttons, kw = ev.out[0]
     assert "Queued" in text and "starting soon" in text and EPISODE_NEW in text
     assert flat_buttons(buttons) == [("✖ Cancel", f"job:x:{job.id}")]
@@ -517,9 +415,12 @@ async def test_a_template_variable_that_cannot_be_filled_is_flagged(ctx):
     assert "in the caption" in ev.texts[0]
 
 
-async def test_the_default_template_never_warns(ctx):
+async def test_default_template_and_manual_names_never_warn(ctx):
     ev = await send_doc(ctx, OWNER, "Plain Movie.mkv")
     assert "⚠️" not in ev.texts[0]  # bracket groups vanish on purpose
+    await say(ctx, OWNER, "/template One Piece - E{episode}")
+    ev = await say(ctx, OWNER, "/rename My Name", reply=document_message("Plain Movie.mkv", mid=40), mid=41)
+    assert "⚠️" not in ev.texts[0]
 
 
 class SlowEvent(FakeEvent):
@@ -537,9 +438,7 @@ class SlowEvent(FakeEvent):
 async def test_jobs_are_ordered_by_the_message_that_triggered_them(ctx):
     await send_doc(ctx, OWNER, "B.mkv", mid=31)
     await send_doc(ctx, OWNER, "A.mkv", mid=30)
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "old.mkv", mid=34)
+    await say(ctx, OWNER, "/rename X", reply=document_message("old.mkv", 1024, mid=5), mid=34)
     assert sorted(j.order for j in ctx.app.queue.jobs.values()) == [30, 31, 34]
     assert [j.file_name for j in ctx.app.queue.for_user(OWNER)] == ["A.mkv", "B.mkv", "old.mkv"]
 
@@ -568,206 +467,28 @@ async def test_a_forwarded_batch_comes_out_in_the_order_it_was_sent(ctx):
     assert ran == [names[1145], names[1146], names[1147]]
 
 
-async def test_rename_picks_a_format_then_renames_the_next_file(ctx):
-    ev = await say(ctx, OWNER, "/rename")
-    data = data_of(ev.out[0][1])
-    assert "fnew" in data                       # with no formats yet, only "new format" is offered
-    assert not any(d.startswith("fm:") for d in data)
-
-    fmt = await ctx.db.create_format(OWNER, "One Piece format")
-    ev = await say(ctx, OWNER, "/rename")
-    assert "One Piece format" in ev.out[0][0]
-    assert f"fm:{fmt['id']}" in data_of(ev.out[0][1])
-
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "rename_format"
-    await send_doc(ctx, OWNER, "[SubsPlease] Tokyo Revengers - 05 (1080p) [ABCD1234].mkv")
-
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == EPISODE_NEW          # the format's template was applied
-    assert OWNER not in ctx.app.pending         # one file per /rename
-
-
-async def test_rename_no_longer_takes_a_name(ctx):
-    ev = await say(ctx, OWNER, "/rename My Custom Name")
-    assert "doesn't take a name" in ev.texts[0]
-    assert not ctx.app.queue.jobs
-
-
-async def test_a_formats_template_reaches_the_file_name(ctx):
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    await ctx.db.update_format(OWNER, fmt["id"], template="TR - {title} - E{episode}")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Tokyo Revengers - 07 (1080p).mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == "TR - Tokyo Revengers - E07.mkv"
-    assert job.settings_override["template"] == "TR - {title} - E{episode}"
-
-
-async def test_a_format_can_suppress_the_thumbnail_entirely(ctx):
-    fmt = await ctx.db.create_format(OWNER, "No Thumb")
-    await ctx.db.update_format(OWNER, fmt["id"], thumb=b"")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Movie.mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.thumbnail_mode == "none" and job.thumbnail is None
-
-
-async def test_a_format_carries_its_own_thumbnail(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Poster")
-    await ctx.db.update_format(OWNER, fmt["id"], thumb=b"\xff\xd8jpeg")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Movie.mkv")
+async def test_rename_command_uses_the_given_name_and_keeps_the_extension(ctx):
+    reply = document_message("old.name.mkv", 10 * 1024 * 1024, mid=33)
+    ev = await say(ctx, OWNER, "/rename My Custom Name", reply=reply, mid=34)
     (job,) = ctx.app.queue.jobs.values()
-    assert job.thumbnail_mode == "custom" and job.thumbnail == b"\xff\xd8jpeg"
-
-
-async def test_deleting_a_format_does_not_break_a_queued_job(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Temp")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Movie.mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    await ctx.db.delete_format(OWNER, fmt["id"])
-    assert job.settings_override is not None      # the job carries resolved settings, not an id
-
-
-async def test_the_format_editor_saves_every_field(ctx):
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    cb = await click(ctx, OWNER, f"fl:{fmt['id']}")
-    assert "One Piece" in cb.edits[0][0]
-    await click(ctx, OWNER, f"fset:fmt_title:{fmt['id']}")
-    assert ctx.app.pending[OWNER].kind == "fmt_title"
-    await say(ctx, OWNER, "One Piece")
-    got = await ctx.db.get_format(OWNER, fmt["id"])
-    assert got["meta"]["title"] == "One Piece"
-
-    await click(ctx, OWNER, f"fset:fmt_title:{fmt['id']}")
-    await say(ctx, OWNER, "default")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["meta"]["title"] is None   # inherit
-
-    await click(ctx, OWNER, f"fthumbnone:{fmt['id']}")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["thumb"] == b""
-    await click(ctx, OWNER, f"fthumbdef:{fmt['id']}")
-    assert (await ctx.db.get_format(OWNER, fmt["id"]))["thumb"] is None
-
-
-async def test_creating_and_deleting_a_format(ctx):
-    await click(ctx, OWNER, "fnew")
-    assert ctx.app.pending[OWNER].kind == "fmt_name"
-    await say(ctx, OWNER, "Dragon Ball")
-    formats = await ctx.db.list_formats(OWNER)
-    assert [f["name"] for f in formats] == ["Dragon Ball"]
-    fmt_id = formats[0]["id"]
-
-    await click(ctx, OWNER, f"fdel:{fmt_id}")
-    await click(ctx, OWNER, f"fdelok:{fmt_id}")
-    assert await ctx.db.list_formats(OWNER) == []
-
-
-async def test_a_format_belongs_to_one_user(ctx):
-    fmt = await ctx.db.create_format(OWNER, "Mine")
-    ev = await click(ctx, ADMIN_CFG, f"fl:{fmt['id']}")
-    assert "MY FORMATS" in ev.edits[0][0]
-    assert await ctx.db.list_formats(ADMIN_CFG) == []
-
-
-async def test_an_open_sequence_collects_files_instead_of_renaming_them(ctx):
-    ev = await say(ctx, OWNER, "/sequence")
-    assert "Send me the files" in ev.texts[0]
-    await send_doc(ctx, OWNER, "Show S01E02.mkv")
-    await send_doc(ctx, OWNER, "Show S01E01.mkv")
-    assert not ctx.app.queue.jobs                    # nothing was renamed
-    seq = await ctx.db.get_sequence(OWNER)
-    assert [i["name"] for i in seq["items"]] == ["Show S01E02.mkv", "Show S01E01.mkv"]
-
-
-async def test_sort_copies_the_files_back_in_order(ctx):
-    await say(ctx, OWNER, "/sequence")
-    await send_doc(ctx, OWNER, "Show S01E02.mkv", mid=11)
-    await send_doc(ctx, OWNER, "Show S01E01.mkv", mid=12)
-    await say(ctx, OWNER, "/sort")
-    # the files go back one at a time, in episode order, with no forward header
-    assert [ids for _to, _from, ids, _kw in ctx.client.copies] == [[12], [11]]
-    assert all(kw.get("drop_author") is True for _to, _from, _ids, kw in ctx.client.copies)
-    assert await ctx.db.get_sequence(OWNER) is None    # the sequence closed
-
-
-async def test_sort_reports_missing_and_duplicate_episodes(ctx):
-    await say(ctx, OWNER, "/sequence")
-    await send_doc(ctx, OWNER, "Show S01E01.mkv", mid=21)
-    await send_doc(ctx, OWNER, "Show S01E03.mkv", mid=22)
-    await send_doc(ctx, OWNER, "Show S01E03 (copy).mkv", mid=23)
-    await say(ctx, OWNER, "/sort")
-    report = [t for _e, t, _k in ctx.client.edited if t and "Sorted" in t]
-    assert report and "S01E02" in report[0]
-    assert "Duplicate S01E03" in report[0]
-
-
-async def test_a_picked_format_wins_over_an_open_sequence(ctx):
-    await say(ctx, OWNER, "/sequence")
-    fmt = await ctx.db.create_format(OWNER, "One Piece")
-    await click(ctx, OWNER, f"fm:{fmt['id']}")
-    await send_doc(ctx, OWNER, "Show S01E01.mkv")
-    (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == "[S01E01] Show.mkv"    # renamed, not collected
-    seq = await ctx.db.get_sequence(OWNER)
-    assert seq["items"] == []
-
-
-async def test_a_sequence_can_be_cancelled(ctx):
-    await say(ctx, OWNER, "/sequence")
-    await send_doc(ctx, OWNER, "Show S01E01.mkv")
-    await click(ctx, OWNER, "sq:cancel")
-    assert await ctx.db.get_sequence(OWNER) is None
-
-
-async def test_check_reports_what_the_bot_extracted(ctx):
-    reply = document_message("Dragon Ball Super Beerus S01E02 1080p.mkv", mid=40, caption="")
-    ev = await say(ctx, OWNER, "/check", reply=reply)
-    text = ev.texts[0]
-    assert "Title ⭆ Dragon Ball Super Beerus" in text
-    assert "Season ⭆ 01" in text and "Episode ⭆ 02" in text
-    assert "Quality ⭆ 1080p" in text
-    assert text.count("➦") == 8              # the name and the caption sections
-
-
-async def test_check_shows_the_caption_section(ctx):
-    reply = document_message("video.mkv", mid=41, caption="Tokyo Revengers S02E05 720p")
-    ev = await say(ctx, OWNER, "/check", reply=reply)
-    text = ev.texts[0]
-    assert "Episode ⭆ 05" in text and "Quality ⭆ 720p" in text
-
-
-async def test_check_needs_a_file(ctx):
-    ev = await say(ctx, OWNER, "/check")
+    assert job.new_name == "My Custom Name.mkv" and job.manual and job.msg_id == 33
+    assert "My Custom Name.mkv" in ev.texts[0]
+
+    ev = await say(ctx, OWNER, "/rename Movie.2024.mp4", reply=reply, mid=35)  # a typed extension never wins
+    assert sorted(j.new_name for j in ctx.app.queue.jobs.values())[1].endswith(".mkv")
+
+
+async def test_rename_usage_messages(ctx):
+    for kwargs in (
+        {"reply": None},                                              # no reply
+        {"reply": FakeMessage("just text", mid=5)},                   # reply to text
+        {"reply": FakeMessage("", mid=6, file=make_file("s.webp"), sticker=True)},
+    ):
+        ev = await say(ctx, OWNER, "/rename New Name", **kwargs)
+        assert "Reply to a file" in ev.texts[0], kwargs
+    ev = await say(ctx, OWNER, "/rename", reply=document_message())  # reply but no name
     assert "Reply to a file" in ev.texts[0]
-
-
-async def test_resize_answers_with_size_buttons(ctx):
-    reply = FakeMessage(mid=60, photo=object(), media_bytes=jpeg())
-    ev = await say(ctx, OWNER, "/resize", reply=reply)
-    data = data_of(ev.out[0][1])
-    assert "rz:320" in data and "rz:640" in data and "rz:1280" in data and "rz:orig" in data
-
-
-async def test_resize_needs_an_image(ctx):
-    ev = await say(ctx, OWNER, "/resize")
-    assert "Reply to an image" in ev.texts[0]
-
-
-async def test_resizing_sends_the_new_image(ctx):
-    reply = FakeMessage(mid=61, photo=object(), media_bytes=jpeg())
-    await say(ctx, OWNER, "/resize", reply=reply)
-    await click(ctx, OWNER, "rz:320")
-    assert ctx.client.files
-    _chat, file, kw = ctx.client.files[-1]
-    assert isinstance(file, io.BytesIO)
-    assert "Set as my thumbnail" in [label for label, _d in flat_buttons(kw.get("buttons"))]
-
-
-async def test_ethumb_needs_a_file(ctx):
-    ev = await say(ctx, OWNER, "/ethumb")
-    assert "Reply to a video" in ev.texts[0]
+    assert not ctx.app.queue.jobs
 
 
 async def test_oversized_files_are_refused(ctx):

tests/test_check.py

@@ -1,119 +0,0 @@
-from bot.parser import Info, effective_info
-from bot.panels import check_report
-from bot.utils import to_small_caps
-
-# the small-capital glyph of every ASCII letter
-SMALL_CAP_TABLE = {
-    "a": "\u1d43", "b": "\u0299", "c": "\u1d04", "d": "\u1d05", "e": "\u1d07",
-    "f": "\ua730", "g": "\u0262", "h": "\u029c", "i": "\u026a", "j": "\u1d0a",
-    "k": "\u1d0b", "l": "\u029f", "m": "\u1d0d", "n": "\u0274", "o": "\u1d0f",
-    "p": "\u1d18", "q": "\u01eb", "r": "\u0280", "s": "\u0073", "t": "\u1d1b",
-    "u": "\u1d1c", "v": "\u1d20", "w": "\u1d21", "x": "\u0078", "y": "\u02bf",
-    "z": "\u1d22",
-}
-
-
-def test_to_small_caps_maps_every_letter_and_leaves_the_rest():
-    assert to_small_caps("Your") == "\u02bf\u1d0f\u1d1c\u0280"   # ʏ ᴏ ᴜ ʀ
-    assert to_small_caps("FileName") == to_small_caps("filename")
-    # The brief wrote this line with the literal "123 /mode!" on both sides, but every
-    # ASCII letter maps, so "mode" must come out small-capped; the literal was a
-    # Unicode-normalisation artefact.  The correct expected value is spelled out below.
-    assert to_small_caps("123 /mode!") == "123 /\u1d0d\u1d0f\u1d05\u1d07!"
-
-
-def test_to_small_caps_covers_the_whole_alphabet():
-    for letter, glyph in SMALL_CAP_TABLE.items():
-        assert to_small_caps(letter) == glyph
-        assert to_small_caps(letter.upper()) == glyph    # both cases share one glyph
-    assert to_small_caps("0123456789 .,!?-_") == "0123456789 .,!?-_"
-
-
-def test_effective_info_uses_the_caption_only_when_it_is_structured():
-    stem = "Dragon Ball Super Beerus S01E02 1080p"
-    assert effective_info(stem, "", "filename").title == "Dragon Ball Super Beerus"
-    # an unstructured caption is discarded entirely
-    assert effective_info(stem, "My Show", "caption").title == "Dragon Ball Super Beerus"
-    # a structured caption wins, and the filename fills in what it lacks
-    info = effective_info(stem, "Beerus 1080p S01E02", "caption")
-    assert info.season == "01" and info.episode == "02" and info.quality == "1080p"
-
-
-def test_effective_info_in_filename_mode_ignores_the_caption():
-    stem = "Dragon Ball Super Beerus S01E02 1080p"
-    info = effective_info(stem, "Beerus 1080p S01E02", "filename")
-    assert info.title == "Dragon Ball Super Beerus"
-    assert info.season == "01" and info.episode == "02" and info.quality == "1080p"
-
-
-def test_effective_info_fills_only_the_fields_the_caption_left_empty():
-    stem = "Dragon Ball Super Beerus S01E02 1080p"
-    info = effective_info(stem, "Beerus 720p", "caption")
-    assert info.title == "Beerus"                                   # the caption wins
-    assert info.quality == "720p"                                   # ... here too
-    assert info.season == "01" and info.episode == "02"             # the filename fills the rest
-
-
-def test_effective_info_ignores_a_blank_caption():
-    stem = "Dragon Ball Super Beerus S01E02 1080p"
-    for blank in ("", "   ", "\n"):
-        info = effective_info(stem, blank, "caption")
-        assert info.title == "Dragon Ball Super Beerus"
-        assert info.season == "01" and info.episode == "02" and info.quality == "1080p"
-
-
-def test_check_report_has_the_agreed_layout():
-    info = Info(title="Dragon Ball Super Beerus", season="01", episode="02", quality="1080p")
-    text = check_report(info, info)
-    assert "\u02bf\u1d0f\u1d1c\u0280" in text                  # ʏ ᴏ ᴜ ʀ — the small-capped header
-    assert "\ua730\u026a\u029f\u1d07\u0274\u1d43\u1d0d\u1d07:" in text   # ꜰɪʟᴇɴᴀᴍᴇ
-    assert "\u27a6 Title \u2b46 Dragon Ball Super Beerus" in text
-    assert "\u27a6 Season \u2b46 01" in text
-    assert "\u27a6 Episode \u2b46 02" in text
-    assert "\u27a6 Quality \u2b46 1080p" in text
-    assert text.count("\u27a6") == 8               # four fields in each of the two sections
-    assert "Chapter" not in text
-
-
-def test_check_report_matches_the_agreed_layout_exactly():
-    info = Info(title="Dragon Ball Super Beerus", season="01", episode="02", quality="1080p")
-    assert check_report(info, info) == (
-        "\u02bf\u1d0f\u1d1c\u0280 \u1d04\u1d43\u0274 \u1d04\u029c\u1d43\u0274\u0262\u1d07 "
-        "\u1d0d\u1d0f\u1d05\u1d07 \u0299\u02bf /mode\n"
-        "\n"
-        "\ua730\u026a\u029f\u1d07\u0274\u1d43\u1d0d\u1d07:\n"
-        "\u27a6 Title \u2b46 Dragon Ball Super Beerus\n"
-        "\u27a6 Season \u2b46 01\n"
-        "\u27a6 Episode \u2b46 02\n"
-        "\u27a6 Quality \u2b46 1080p\n"
-        "\n"
-        "\u1d04\u1d43\u1d18\u1d1b\u026a\u1d0f\u0274 \u1d0d\u1d0f\u1d05\u1d07:\n"
-        "\u27a6 Title \u2b46 Dragon Ball Super Beerus\n"
-        "\u27a6 Season \u2b46 01\n"
-        "\u27a6 Episode \u2b46 02\n"
-        "\u27a6 Quality \u2b46 1080p"
-    )
-
-
-def test_check_report_shows_none_for_empty_values_and_extra_fields_only_when_present():
-    text = check_report(Info(title="X"), Info(title="X"))
-    assert "\u27a6 Season \u2b46 None" in text
-    assert "Year" not in text and "Codec" not in text
-    text = check_report(Info(title="X", year="2023", codec="HEVC"), Info(title="X"))
-    assert "\u27a6 Year \u2b46 2023" in text and "\u27a6 Codec \u2b46 HEVC" in text
-
-
-def test_check_report_shows_year_and_codec_only_in_the_section_that_has_them():
-    text = check_report(Info(title="X"), Info(title="X", year="2023", codec="HEVC"))
-    name_section, caption_section = text.split(
-        "\u1d04\u1d43\u1d18\u1d1b\u026a\u1d0f\u0274 \u1d0d\u1d0f\u1d05\u1d07:"
-    )
-    assert "Year" not in name_section and "Codec" not in name_section
-    assert "\u27a6 Year \u2b46 2023" in caption_section
-    assert "\u27a6 Codec \u2b46 HEVC" in caption_section
-
-
-def test_check_report_escapes_values_that_come_from_the_file_name():
-    text = check_report(Info(title="<b>Bold</b> & Co"), Info(title="X"))
-    assert "<b>Bold</b>" not in text
-    assert "&lt;b&gt;Bold&lt;/b&gt; &amp; Co" in text

tests/test_db.py

@@ -3,6 +3,14 @@ import pytest
 from bot.db import DEFAULT_SETTINGS, Database, normalize_database_url
 
 
+@pytest.fixture
+async def db(tmp_path):
+    database = Database(f"sqlite+aiosqlite:///{tmp_path}/t.db")
+    await database.init()
+    yield database
+    await database.close()
+
+
 def test_normalize_postgres_urls():
     url, args = normalize_database_url("postgres://u:p@host/db?sslmode=require&channel_binding=require")
     assert url == "postgresql+asyncpg://u:p@host/db"
@@ -77,65 +85,3 @@ async def test_first_use_by_many_concurrent_handlers_does_not_collide(db):
     # the same goes for the other writers that create the row on first use
     await asyncio.gather(*(db.record_job(78, 10) for _ in range(5)), *(db.set_thumb(79, b"x") for _ in range(5)))
     assert await db.count_users() == 3
-
-
-async def test_formats_crud_and_the_twelve_slot_limit(db):
-    assert await db.count_formats(7) == 0
-    first = await db.create_format(7, "One Piece format")
-    assert first["id"] and first["name"] == "One Piece format"
-    assert first["template"] is None and first["keep_audio"] is None
-    assert first["meta"]["title"] is None
-    assert await db.create_format(7, "One Piece format") is None   # the name is taken
-    assert await db.create_format(7, "   ") is None                # a blank name
-    for i in range(11):
-        assert await db.create_format(7, f"F{i}") is not None
-    assert await db.count_formats(7) == 12
-    assert await db.create_format(7, "Thirteenth") is None          # the limit
-    assert await db.count_formats(8) == 0                         # per user
-    assert [f["name"] for f in await db.list_formats(7)][0] == "One Piece format"
-
-
-async def test_format_fields_round_trip_through_the_database(db):
-    fmt = await db.create_format(7, "Dragon Ball")
-    assert await db.update_format(7, fmt["id"], template="[S{season}E{episode}] {title}",
-                                  meta={"title": "", "author": "Kuririn"},
-                                  keep_audio=[], keep_subtitle=["english"])
-    got = await db.get_format(7, fmt["id"])
-    assert got["template"] == "[S{season}E{episode}] {title}"
-    assert got["meta"]["title"] == "" and got["meta"]["author"] == "Kuririn"
-    assert got["meta"]["artist"] is None
-    assert got["keep_audio"] == [] and got["keep_subtitle"] == ["english"]
-    assert await db.get_format(9, fmt["id"]) is None               # another user
-    assert await db.delete_format(7, fmt["id"]) is True
-    assert await db.delete_format(7, fmt["id"]) is False
-
-
-async def test_format_thumbnail_distinguishes_inherit_from_none(db):
-    fmt = await db.create_format(7, "Posters")
-    assert (await db.get_format(7, fmt["id"]))["thumb"] is None    # inherit
-    await db.update_format(7, fmt["id"], thumb=b"")
-    assert (await db.get_format(7, fmt["id"]))["thumb"] == b""     # explicitly none
-    await db.update_format(7, fmt["id"], thumb=b"\xff\xd8jpeg")
-    assert (await db.get_format(7, fmt["id"]))["thumb"] == b"\xff\xd8jpeg"
-    await db.update_format(7, fmt["id"], thumb=None)
-    assert (await db.get_format(7, fmt["id"]))["thumb"] is None    # back to inherit
-
-
-async def test_sequence_and_start_media(db):
-    assert await db.get_sequence(3) is None
-    await db.set_sequence(3, [{"msg_id": 1, "name": "a.mkv", "caption": ""}])
-    seq = await db.get_sequence(3)
-    assert seq["items"][0]["name"] == "a.mkv" and seq["copied"] == 0
-    await db.set_sequence(3, seq["items"], copied=2)
-    assert (await db.get_sequence(3))["copied"] == 2
-    await db.clear_sequence(3)
-    assert await db.get_sequence(3) is None
-
-    assert await db.get_start_media() is None
-    await db.set_start_media("gif", b"\x00gif")
-    assert (await db.get_start_media())["kind"] == "gif"
-    assert (await db.get_start_media())["data"] == b"\x00gif"
-    await db.set_start_media("image", b"\xff\xd8")
-    assert (await db.get_start_media())["kind"] == "image"   # one row, replaced
-    await db.clear_start_media()
-    assert await db.get_start_media() is None

tests/test_formats.py

@@ -1,67 +0,0 @@
-from bot.db import DEFAULT_SETTINGS
-from bot.formats import apply_format_field, resolve_format, resolve_thumbnail
-
-
-def test_a_format_that_inherits_everything_changes_nothing():
-    fmt = {"template": None, "meta": {f: None for f in ("title", "author", "artist", "audio", "subtitle", "video")},
-           "keep_audio": None, "keep_subtitle": None}
-    settings = dict(DEFAULT_SETTINGS, template="GLOBAL", keep_audio=["english"])
-    assert resolve_format(fmt, settings) == settings
-
-
-def test_a_format_overlays_only_the_fields_it_sets():
-    fmt = {"template": "[S{season}E{episode}] {title}",
-           "meta": {"title": "One Piece", "author": None, "artist": None, "audio": None, "subtitle": None, "video": None},
-           "keep_audio": [], "keep_subtitle": None}
-    settings = dict(DEFAULT_SETTINGS, template="GLOBAL", keep_audio=["english"], keep_subtitle=["japanese"])
-    out = resolve_format(fmt, settings)
-    assert out["template"] == "[S{season}E{episode}] {title}"
-    assert out["meta"]["title"] == "One Piece" and out["meta"]["author"] == ""
-    assert out["keep_audio"] == [] and out["keep_subtitle"] == ["japanese"]   # inherit
-    assert settings["template"] == "GLOBAL"                                   # the input is not mutated
-
-
-def test_resolve_thumbnail_states():
-    inherit = {"thumb": None}
-    custom = {"thumb": b"\xff\xd8jpeg"}
-    none = {"thumb": b""}
-    assert resolve_thumbnail(inherit, b"GLOBAL") == ("auto", b"GLOBAL")
-    assert resolve_thumbnail(inherit, None) == ("auto", None)     # a video frame may still be used
-    assert resolve_thumbnail(custom, b"GLOBAL") == ("custom", b"\xff\xd8jpeg")
-    assert resolve_thumbnail(none, b"GLOBAL") == ("none", None)    # explicitly none: never a frame
-
-
-async def test_apply_format_field_clearing_and_inheriting(db):
-    fmt = await db.create_format(1, "One Piece")
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_title", "One Piece")
-    assert ok and "One Piece" in msg
-    ok, _ = await apply_format_field(db, 1, fmt["id"], "fmt_title", "off")
-    assert ok
-    assert (await db.get_format(1, fmt["id"]))["meta"]["title"] == ""      # explicitly empty
-    ok, _ = await apply_format_field(db, 1, fmt["id"], "fmt_keep_audio", "off")
-    assert ok
-    assert (await db.get_format(1, fmt["id"]))["keep_audio"] == []          # keep every track
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_name", "off")
-    assert not ok                                                          # a format must have a name
-
-
-async def test_apply_format_field_saves_a_template_and_a_keep_list(db):
-    fmt = await db.create_format(1, "Dragon Ball")
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_template", "[S{season}E{episode}] {title}")
-    assert ok and "Template saved" in msg
-    assert (await db.get_format(1, fmt["id"]))["template"] == "[S{season}E{episode}] {title}"
-    ok, _ = await apply_format_field(db, 1, fmt["id"], "fmt_template", "off")
-    assert ok
-    assert (await db.get_format(1, fmt["id"]))["template"] is None          # back to inherit
-
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_keep_subtitle", "English Japanese")
-    assert ok and "English" in msg
-    assert (await db.get_format(1, fmt["id"]))["keep_subtitle"] == ["english", "japanese"]
-
-    ok, msg = await apply_format_field(db, 1, fmt["id"], "fmt_keep_subtitle", "0")
-    assert not ok and "start at 1" in msg
-
-
-async def test_apply_format_field_rejects_a_missing_format(db):
-    ok, msg = await apply_format_field(db, 1, 999, "fmt_title", "x")
-    assert not ok and "gone" in msg

tests/test_media.py

@@ -9,15 +9,12 @@ from bot.media import (
     apply_plan,
     build_plan,
     canonical_lang,
-    extract_frame,
     format_tracks,
     make_video_thumbnail,
     parse_probe,
-    parse_size,
     parse_track_tokens,
     prepare_thumb,
     probe,
-    resize_image,
     resolve_tokens,
     validate_track_tokens,
 )
@@ -322,41 +319,3 @@ async def test_thumbnail_and_prepare_thumb(media_dir, tmp_path):
     img = Image.open(io.BytesIO(jpg))
     assert max(img.size) <= 320 and len(jpg) <= 200 * 1024 and img.format == "JPEG"
     assert not await make_video_thumbnail(tmp_path / "missing.mkv", tmp_path / "x.jpg", 1.0)
-
-
-@needs_ffmpeg
-async def test_extract_frame_keeps_the_source_width(media_dir, tmp_path):
-    out = tmp_path / "frame.jpg"
-    assert await extract_frame(media_dir / "sample.mkv", out, 2.0)
-    from PIL import Image
-    import io
-
-    img = Image.open(io.BytesIO(out.read_bytes()))
-    assert img.size[0] == 320          # the sample video is 320 wide
-    assert not await extract_frame(tmp_path / "missing.mkv", tmp_path / "x.jpg", 1.0)
-
-
-def test_parse_size_accepts_a_width_or_an_exact_size():
-    assert parse_size("800") == (800, None, None)
-    assert parse_size("800x450") == (800, 450, None)
-    assert parse_size(" 640 ") == (640, None, None)
-    w, h, err = parse_size("huge")
-    assert (w, h) == (None, None) and "size" in err
-    w, h, err = parse_size("0")
-    assert (w, h) == (None, None) and "1 pixel" in err
-
-
-def test_resize_image_keeps_the_aspect_ratio_or_forces_the_exact_size():
-    import io
-
-    from PIL import Image
-
-    buf = io.BytesIO()
-    Image.new("RGB", (1000, 500), (10, 20, 30)).save(buf, "PNG")
-    data = buf.getvalue()
-    out = Image.open(io.BytesIO(resize_image(data, width=200)))
-    assert out.size == (200, 100)
-    out = Image.open(io.BytesIO(resize_image(data, width=200, height=200)))
-    assert out.size == (200, 200)
-    out = Image.open(io.BytesIO(resize_image(data, height=250)))
-    assert out.size == (500, 250)

tests/test_sequence.py

@@ -1,57 +0,0 @@
-from bot.sequence import detect_episodes, format_report, plan_sort
-
-
-def items(*names):
-    return [{"msg_id": i, "name": n, "caption": ""} for i, n in enumerate(names)]
-
-
-def test_episodes_are_detected_from_the_file_name():
-    out = detect_episodes(items("Show S01E02.mkv", "Show S01E10.mkv"), "filename")
-    assert [(i["season"], i["episode"]) for i in out] == [("01", "02"), ("01", "10")]
-
-
-def test_the_caption_is_used_in_caption_mode():
-    out = detect_episodes(
-        [{"msg_id": 1, "name": "video.mkv", "caption": "Show S02E05 1080p"}], "caption"
-    )
-    assert (out[0]["season"], out[0]["episode"]) == ("02", "05")
-    out = detect_episodes(
-        [{"msg_id": 1, "name": "video.mkv", "caption": "Show S02E05 1080p"}], "filename"
-    )
-    assert out[0]["episode"] == ""
-
-
-def test_sorting_is_by_season_then_episode_ascending():
-    out = plan_sort(detect_episodes(
-        items("S01E10.mkv", "S02E01.mkv", "S01E02.mkv", "S01E03.mkv"), "filename"))
-    assert [i["name"] for i in out.ordered] == ["S01E02.mkv", "S01E03.mkv", "S01E10.mkv", "S02E01.mkv"]
-
-
-def test_missing_episodes_are_reported_per_season():
-    out = plan_sort(detect_episodes(items("S01E01.mkv", "S01E04.mkv", "S02E01.mkv"), "filename"))
-    assert out.missing == ["S01E02", "S01E03"]
-
-
-def test_duplicate_episodes_are_reported_with_their_file_names():
-    out = plan_sort(detect_episodes(items("S01E02.mkv", "S01E02 (copy).mkv", "S01E03.mkv"), "filename"))
-    assert len(out.duplicates) == 1
-    assert out.duplicates[0].episode == "02"
-    assert out.duplicates[0].names == ["S01E02.mkv", "S01E02 (copy).mkv"]
-
-
-def test_a_file_without_an_episode_is_kept_and_reported():
-    out = plan_sort(detect_episodes(items("S01E02.mkv", "bonus.mkv", "extra.mkv"), "filename"))
-    assert [i["name"] for i in out.ordered] == ["S01E02.mkv", "bonus.mkv", "extra.mkv"]
-    assert out.no_episode == ["bonus.mkv", "extra.mkv"]
-
-
-def test_the_report_lists_only_what_is_wrong():
-    out = plan_sort(detect_episodes(items("S01E01.mkv", "S01E03.mkv"), "filename"))
-    text = format_report(out, 2)
-    assert "S01E02" in text and "Duplicate" not in text and "No episode" not in text
-
-
-def test_the_report_names_the_duplicates_and_the_odds():
-    out = plan_sort(detect_episodes(items("S01E01.mkv", "S01E01.mkv", "bonus.mkv"), "filename"))
-    text = format_report(out, 3)
-    assert "Duplicate S01E01" in text and "No episode number" in text and "bonus.mkv" in text

tests/test_settings_ops.py

@@ -1,11 +1,19 @@
 import pytest
 
-from bot.db import DEFAULT_SETTINGS
+from bot.db import DEFAULT_SETTINGS, Database
 from bot.settings_ops import META_COMMANDS, META_KINDS, apply_setting, parse_channel, preview_template
 
 UID = 7
 
 
+@pytest.fixture
+async def db(tmp_path):
+    d = Database(f"sqlite+aiosqlite:///{tmp_path}/s.db")
+    await d.init()
+    yield d
+    await d.close()
+
+
 async def get(db):
     return await db.get_settings(UID)
 

tests/test_speedtest.py

@@ -1,51 +0,0 @@
-import pytest
-
-from bot.speedtest import format_speed, parse_ookla_json
-
-# A real `ookla-speedtest --accept-license --accept-gdpr --format=json` run.
-RAW = """{"type":"result","timestamp":"2026-10-20T10:45:15Z",
- "ping":{"jitter":0.273,"latency":2.998,"low":2.833,"high":3.315},
- "download":{"bandwidth":11034552,"bytes":39707592,"elapsed":3602,
-   "latency":{"iqm":16.372,"low":6.344,"high":48.044,"jitter":3.565}},
- "upload":{"bandwidth":11886628,"bytes":162534754,"elapsed":14821,
-   "latency":{"iqm":128.627,"low":5.8,"high":523.355,"jitter":48.431}},
- "packetLoss":0,"isp":"ACT Fibernet",
- "interface":{"internalIp":"192.168.32.3","name":"wlan0","externalIp":"49.204.136.88"},
- "server":{"id":60836,"host":"chn.infonetcomm.com","port":8080,"name":"ACT FIBERNET",
-   "location":"Chennai","country":"India","ip":"2406:7400:b0:1::2"},
- "result":{"id":"18dc","url":"https://www.speedtest.net/result/c/18dc","persisted":true}}"""
-
-
-def test_parse_ookla_json_reads_the_speeds():
-    r = parse_ookla_json(RAW)
-    assert r.download_mbps == pytest.approx(11.034552, rel=1e-4)
-    assert r.upload_mbps == pytest.approx(11.886628, rel=1e-4)
-    assert r.ping_ms == 2.998            # the CLI reports the round trip as "latency"
-    assert r.server == "ACT FIBERNET — Chennai, India"
-    assert r.isp == "ACT Fibernet"
-
-
-def test_parse_ookla_json_survives_a_leading_licence_notice():
-    r = parse_ookla_json("You may only use this Speedtest software...\n" + RAW)
-    assert r.download_mbps == pytest.approx(11.034552, rel=1e-4)
-
-
-def test_parse_ookla_json_rejects_rubbish():
-    with pytest.raises(ValueError):
-        parse_ookla_json("not json")
-    with pytest.raises(ValueError):
-        parse_ookla_json("{}")
-    with pytest.raises(ValueError):
-        parse_ookla_json("[]")
-
-
-def test_format_speed_shows_the_numbers():
-    text = format_speed(parse_ookla_json(RAW))
-    assert "11.03" in text and "11.89" in text and "3" in text
-    assert "ACT FIBERNET" in text and "Chennai" in text and "ACT Fibernet" in text
-
-
-def test_format_speed_copes_with_missing_details():
-    text = format_speed(parse_ookla_json('{"download":{"bandwidth":1000000},"upload":{"bandwidth":2000000}}'))
-    assert "1.00 Mbps" in text and "2.00 Mbps" in text
-    assert "Server" not in text and "ISP" not in text

tests/test_telegraph.py

@@ -1,44 +0,0 @@
-from bot.telegraph import build_page, build_summary
-
-PROBE = {
-    "format": {"filename": "movie.mkv", "format_name": "matroska,webm", "duration": "120.0",
-               "size": "1048576", "bit_rate": "8000000",
-               "tags": {"title": "Movie Title"}},
-    "streams": [
-        {"index": 0, "codec_type": "video", "codec_name": "h264", "width": 1920, "height": 1080,
-         "r_frame_rate": "24/1", "bit_rate": "7000000", "disposition": {"default": 1}},
-        {"index": 1, "codec_type": "audio", "codec_name": "aac", "channels": 2, "sample_rate": "48000",
-         "tags": {"language": "eng", "title": "English"}},
-        {"index": 2, "codec_type": "subtitle", "codec_name": "subrip",
-         "tags": {"language": "eng"}},
-    ],
-    "chapters": [{"id": 0, "start_time": "0.0", "end_time": "60.0", "tags": {"title": "Intro"}}],
-}
-
-
-def test_build_page_lists_the_format_the_streams_and_the_chapters():
-    html = build_page(PROBE, "movie.mkv")
-    assert "movie.mkv" in html and "matroska" in html
-    assert "h264" in html and "1920x1080" in html
-    assert "aac" in html and "English" in html
-    assert "subrip" in html
-    assert "Intro" in html
-    assert "Movie Title" in html
-    assert "<pre" in html
-
-
-def test_build_page_includes_the_raw_json():
-    html = build_page(PROBE, "movie.mkv")
-    assert '"streams"' in html                # the raw ffprobe output is in the page
-    assert "h264" in html.split("<pre")[1]      # ...inside the <pre> block
-
-
-def test_build_page_survives_an_empty_probe():
-    html = build_page({}, "nothing.mkv")
-    assert "nothing.mkv" in html
-
-
-def test_the_plain_summary_has_no_html():
-    text = build_summary(PROBE, "movie.mkv")
-    assert "movie.mkv" in text and "1920x1080" in text and "Intro" in text
-    assert "<" not in text

tests/tgfakes.py

@@ -23,8 +23,7 @@ def make_file(name: Optional[str] = "Movie.mkv", size: int = 5 * 1024 * 1024, mi
 class FakeMessage:
     def __init__(self, text: str = "", *, mid: int = 1, sender: int = 1, file: Any = None, video: bool = False,
                  audio: bool = False, photo: bool = False, sticker: bool = False, gif: bool = False,
-                 voice: bool = False, video_note: bool = False, fwd: bool = False, out: bool = False,
-                 media_bytes: Optional[bytes] = None):
+                 voice: bool = False, video_note: bool = False, fwd: bool = False, out: bool = False):
         self.id = mid
         self.message = text
         self.raw_text = text
@@ -41,10 +40,6 @@ class FakeMessage:
         self.voice = object() if voice else None
         self.video_note = object() if video_note else None
         self.media = object() if (file is not None or photo) else None
-        self.media_bytes = media_bytes
-
-    async def download_media(self, file: Any = None) -> Optional[bytes]:
-        return self.media_bytes
 
 
 def document_message(name: str = "Movie.mkv", size: int = 5 * 1024 * 1024, *, mid: int = 10, caption: str = "",
@@ -137,7 +132,6 @@ class FakeClient:
         self.sent: List[tuple] = []     # send_message(entity, text, **kw)
         self.files: List[tuple] = []    # send_file(entity, file, **kw)
         self.edited: List[tuple] = []   # edit_message(entity, text, **kw)
-        self.copies: List[tuple] = []   # forward_messages(to, messages, from_peer, **kw)
         self.requests: List[Any] = []   # raw MTProto requests
         self.bad_entities: set = set()
         self.fail_send_file = False
@@ -169,10 +163,6 @@ class FakeClient:
             text, message = message, None
         self.edited.append((entity, text, {**kw, "message": message}))
 
-    async def forward_messages(self, to: Any, messages: Any, from_peer: Any = None, **kw: Any) -> List[SimpleNamespace]:
-        self.copies.append((to, from_peer, list(messages), kw))
-        return [SimpleNamespace(id=4000 + len(self.copies))]
-
 
 async def dispatch(client: FakeClient, event: Any) -> None:
     """Run ``event`` through the registered handlers like Telethon's dispatcher."""