Automated sync from GitHub

.gitattributes

@@ -1,8 +1,8 @@
+*.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
-*.png filter=lfs diff=lfs merge=lfs -text
-*.ttf filter=lfs diff=lfs merge=lfs -text

bot/app.py

@@ -29,7 +29,6 @@ from .formats import (
     FIELD_KINDS,
     KIND_LABELS,
     NAME_MAX,
-    AutoFormatSettings,
     FormatSettings,
     default_auto_format,
     default_metadata_changes,
@@ -63,7 +62,8 @@ COMMANDS = [
     ("check", "See what I can read from a file (reply to it)"),
     ("mediainfo", "Full media details of a file on Telegraph (reply to it)"),
     ("ethumb", "Extract the thumbnail of a file or video"),
-    ("resize", "Resize an image, for thumbnails"),
+    ("size", "Get the dimensions of a picture (reply to it)"),
+    ("resize", "Resize a picture to an exact size (reply to it)"),
     ("queue", "Show your queued files"),
     ("cancel", "Cancel your current job"),
     ("speed", "Test the bot's internet speed (Ookla)"),
@@ -72,22 +72,27 @@ COMMANDS = [
 ]
 OWNER_COMMANDS = {"addadmin", "deladmin", "admins", "smedia"}
 BACK = {
-    "template": "rename", "remove": "rename", "caption": "cap",
+    "remove": "rename",
     "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", "auto"}
+PANEL_NAMES = {"home", "rename", "meta", "tool", "ftype", "help", "admin", "formats", "auto"}
 QUEUE_SETTLE = 1.5  # seconds an idle worker waits so files sent together are queued in message order
 ONE_FILE_WAIT = 600  # seconds the bot waits for the file after /rename (or /ethumb ...) before forgetting about it
 ONE_SHOT_GRACE = 8  # seconds after a one-file command during which further files get a hint, not an auto-rename
 ONE_SHOT_TAKES = {  # what each one-file command consumes; further files of that kind sent right after it are skipped
-    "rename": {"doc"}, "ethumb": {"doc"}, "resize": {"doc", "photo"}, "smedia": {"doc", "photo", "gif"},
+    "rename": {"doc"}, "ethumb": {"doc"}, "smedia": {"doc", "photo", "gif"},
 }
 ETHUMB_FRAME_WIDTH = 1280
 START_MEDIA_MAX_BYTES = 10 * 1024 * 1024  # biggest /start picture or GIF; a copy of it is kept in the database
 START_IMAGE_BOX = 1280  # pictures are shrunk to fit this box, as Telegram does with photos
-RESIZE_MAX_BYTES = 20 * 1024 * 1024
+RESIZE_MAX_BYTES = 20 * 1024 * 1024  # biggest picture /size and /resize read
+RESIZE_MAX_SIDE = 4096  # the biggest width or height /resize makes
+PHOTO_MAX_SIDE = 1280  # Telegram shrinks a photo to this; /resize sends anything bigger as a file so its size stays exact
+PHOTO_MAX_BYTES = 10 * 1024 * 1024  # biggest photo Telegram takes
+PHOTO_MAX_RATIO = 20  # ... and the longer side of a photo can't be more than this many times the shorter one
+HINT_SECONDS = 5  # how long the hint of /resize stays before it is removed
 SEQUENCE_WAIT = 1800  # seconds /sequence keeps the collected files without a new one arriving
 SEQUENCE_MAX = 1000  # files one /sequence collects
 SEQUENCE_STATUS_DELAY = 1.2  # seconds without a new file before "N files collected" is sent
@@ -119,7 +124,7 @@ class Pending:
 
 @dataclass
 class Mode:
-    """What a user's next files are for: a /rename format session, /sequence, /ethumb, /resize or /smedia."""
+    """What a user's next files are for: a /rename format session, /sequence, /ethumb or /smedia."""
 
     kind: str
     ttl: float
@@ -161,6 +166,12 @@ def is_image(message: Any) -> bool:
     )
 
 
+def fits_as_photo(width: int, height: int, size: int) -> bool:
+    """Does Telegram keep a picture of this many pixels and bytes as a photo, exactly as it is?  (It shrinks big ones.)"""
+    longest, shortest = max(width, height), min(width, height)
+    return longest <= PHOTO_MAX_SIDE and longest <= PHOTO_MAX_RATIO * shortest and size <= PHOTO_MAX_BYTES
+
+
 def sent_as(message: Any) -> str:
     """How Telegram labels the file: a video, an audio file, a voice message ..., or a plain document."""
     for attr, label in (
@@ -347,7 +358,7 @@ class App:
             "metadata": self.cmd_metadata, "keepaudio": self._cmd_keep("keep_audio", "Keep Audio", "/keepaudio English Japanese"),
             "keepsubtitle": self._cmd_keep("keep_subtitle", "Keep Subtitle", "/keepsubtitle English"),
             "tracks": self.cmd_tracks, "check": self.cmd_check, "mediainfo": self.cmd_mediainfo,
-            "ethumb": self.cmd_ethumb, "resize": self.cmd_resize,
+            "ethumb": self.cmd_ethumb, "size": self.cmd_size, "resize": self.cmd_resize,
             "removewords": self.cmd_remove, "setchannel": self.cmd_setchannel, "queue": self.cmd_queue,
             "cancel": self.cmd_cancel, "speed": self.cmd_speed, "status": self.cmd_status, "stats": self.cmd_stats,
             "addadmin": self.cmd_addadmin, "deladmin": self.cmd_deladmin, "admins": self.cmd_admins, "smedia": self.cmd_smedia,
@@ -388,9 +399,6 @@ class App:
             return panels.home(s, owner=self.is_owner(uid), auto=await self.db.get_auto_format(uid))
         if name == "rename":
             return panels.rename(s, await self.db.get_auto_format(uid))
-        if name == "cap":
-            auto = await self.db.get_auto_format(uid)
-            return panels.caption(auto, bool(auto and auto["has_thumb"]))
         if name == "meta":
             return panels.metadata(s)
         if name == "tool":
@@ -540,10 +548,6 @@ class App:
         text, rows = await self.panel(uid, "meta")
         await self._reply(event, text, rows)
 
-    def _store(self, kind: str) -> Any:
-        """What keeps a setting: the template and the caption are those of the auto format in use, the rest are the user's own."""
-        return AutoFormatSettings(self.db) if kind in ("template", "caption") else self.db
-
     async def cmd_remove(self, event: Any) -> None:
         arg = self._args(event)
         uid = event.sender_id
@@ -611,48 +615,17 @@ class App:
         await self.db.update_settings(uid, target_channel=cid)
         await self._reply(event, f"✅ Renamed files will go to <code>{cid}</code>." if cid else "✅ Renamed files will come back to this chat.")
 
-    async def _thumb_format(self, uid: int, fid: Optional[int] = None) -> Optional[Dict[str, Any]]:
-        """The auto format a thumbnail button is about.
-
-        A button names its format (``th:rm:12``), so an old message never reaches the thumbnail of whichever format is in use
-        now; the buttons of messages from before that carry no id and mean the one in use.  ``None``: there is no such format.
-        """
-        if fid is None:
-            return await self.db.get_auto_format(uid)
-        fmt = await self.db.get_format(uid, fid)
-        return fmt if fmt is not None and fmt["kind"] == "auto" else None
-
-    async def _auto_thumb(self, uid: int, fid: Optional[int] = None) -> Tuple[Optional[Dict[str, Any]], Optional[bytes]]:
-        """``(the auto format, its thumbnail)``; the thumbnail is ``None`` when the format has none."""
-        auto = await self._thumb_format(uid, fid)
-        return auto, (await self.db.get_format_thumb(uid, auto["id"]) if auto and auto["has_thumb"] else None)
-
-    async def _delete_auto_thumb(self, uid: int, fid: Optional[int] = None) -> bool:
-        """Remove the thumbnail of an auto format (the one in use unless ``fid`` names it); ``False`` when there is none."""
-        auto = await self._thumb_format(uid, fid)
-        if auto is None or not auto["has_thumb"]:
-            return False
-        return await self.db.set_format_thumb(uid, auto["id"], None)
-
-    async def _send_thumb(self, chat_id: int, data: bytes, fid: int) -> None:
-        bio = io.BytesIO(data)
-        bio.name = "thumbnail.jpg"
-        await self.client.send_file(
-            chat_id, bio, caption="Thumbnail of your auto format",
-            buttons=panels.to_buttons([[("🗑 Delete", f"th:rm:{fid}"), ("✖ Close", "x:close")]]),
-        )
-
     async def on_photo(self, event: Any) -> None:
+        """A photo is taken only when a format is waiting for its thumbnail (or /smedia for its picture); any other one is ignored."""
         uid = event.sender_id
         p = self.pending.get(uid)
         if not (p is not None and p.kind == "fmt:thumb" and p.expires >= time.time()):
             if await self._image_mode(event):
                 return
             hint = self._extra_file_hint(uid, "photo")
-            if hint is not None:
-                if hint:
-                    await self._reply(event, hint)
-                return
+            if hint:
+                await self._reply(event, hint)
+            return
         raw = await event.download_media(bytes)
         if not raw:
             await self._reply(event, "❌ I couldn't download that photo.")
@@ -662,15 +635,7 @@ class App:
         except Exception:  # noqa: BLE001
             await self._reply(event, "❌ I couldn't read that image.")
             return
-        if p is not None and p.kind == "fmt:thumb" and p.expires >= time.time():
-            await self._format_thumb_saved(event, p, thumb)
-            return
-        auto = await self.db.ensure_auto_format(uid)
-        await self.db.set_format_thumb(uid, auto["id"], thumb)
-        await self._reply(
-            event, f"✅ Thumbnail saved for your auto format <b>{esc(clip(auto['name'], 30))}</b>. It will be used for the files I send back.",
-            [[("🗑 Delete", f"th:rm:{auto['id']}"), ("✖ Close", "x:close")]],
-        )
+        await self._format_thumb_saved(event, p, thumb)
 
     async def on_gif(self, event: Any) -> None:
         if await self._image_mode(event):
@@ -1166,116 +1131,91 @@ class App:
         await self.client.send_file(event.chat_id, bio, caption=f"🖼 Thumbnail of <b>{esc(clip(name, 80))}</b>", parse_mode="html")
         await self._delete_quietly(event.chat_id, status.id)
 
-    async def cmd_resize(self, event: Any) -> None:
-        uid = event.sender_id
-        self.pending.pop(uid, None)
-        arg = self._args(event)
-        box = None
-        if arg:
-            box = media.parse_size(arg)
-            if box is None:
-                await self._reply(event, "❌ Send a size like <code>/resize 320</code> or <code>/resize 320x180</code> (16 to 4096 pixels).")
-                return
-        reply = await event.get_reply_message()
-        if reply is not None and is_image(reply):  # sent as a reply to the image: do it now (thumbnail size unless told otherwise)
-            await self._send_resized(event, reply, box or (media.THUMB_BOX, media.THUMB_BOX))
-            return
-        if box is None:
-            text, rows = panels.resize_menu()
-            await self._reply(event, text, rows)
-            return
-        await self._wait_for_image(event, box)
+    async def _image_mode(self, event: Any) -> bool:
+        """Give an incoming picture or GIF to /smedia when it is waiting for one.  True when the message was taken care of."""
+        mode = self._mode(event.sender_id, "smedia")
+        if mode is None:
+            return False
+        await self._take_start_media(event, mode)
+        return True
 
-    async def _wait_for_image(self, event: Any, box: Any) -> None:
-        mode = self._start_mode(event.sender_id, "resize", ONE_FILE_WAIT, {"box": box})
-        text, rows = panels.resize_ready(box, ONE_FILE_WAIT // 60)
-        await self._reply(event, text + (f"\n\n{mode.dropped}" if mode.dropped else ""), rows)
+    # ----------------------------------------------------------------- /size, /resize
+    async def _picture_of(self, msg: Any) -> Tuple[Optional[bytes], str]:
+        """``(the picture, "")`` of a message, or ``(None, why there is none)``.
 
-    async def _cb_resize(self, event: Any, uid: int, parts: List[str]) -> None:
-        self.pending.pop(uid, None)
-        action = parts[1] if len(parts) > 1 else ""
-        if action == "s" and len(parts) == 3 and parts[2].isdigit() and int(parts[2]) in dict(panels.RESIZE_PRESETS):
-            box = (int(parts[2]), int(parts[2]))
-            mode = self._start_mode(uid, "resize", ONE_FILE_WAIT, {"box": box})
-            text, rows = panels.resize_ready(box, ONE_FILE_WAIT // 60)
-            await self._edit_panel(event, text + (f"\n\n{mode.dropped}" if mode.dropped else ""), rows)
-            await event.answer(f"Size: {panels.describe_box(box)}")
-        elif action == "custom":
-            self.pending[uid] = Pending(
-                kind="resize:size", chat_id=event.chat_id, msg_id=event.message_id, back="", is_photo=False,
-                expires=time.time() + self.PENDING_TTL,
-            )
-            await self._edit_panel(event, panels.RESIZE_CUSTOM_PROMPT, [[("✖ Cancel", "rz:menu")]])
-            await event.answer()
-        elif action == "menu":
-            if self._mode(uid, "resize") is not None:
-                self._end_mode(uid)
-            text, rows = panels.resize_menu()
-            await self._edit_panel(event, text, rows)
-            await event.answer()
-        elif action == "stop":
-            if self._mode(uid, "resize") is not None:
-                self._end_mode(uid)
-            await self._edit_panel(event, "⏹ Stopped. Send /resize again to resize an image.", [[("✖ Close", "x:close")]])
-            await event.answer()
+        A photo, and a file that is a picture, are taken whole.  Anything else (a video, a GIF, a sticker ...) gives the largest
+        preview Telegram keeps with it.
+        """
+        if getattr(msg, "photo", None) is not None or is_image(msg):
+            size = int(msg.file.size or 0) if getattr(msg, "file", None) is not None else 0
+            if size > RESIZE_MAX_BYTES:
+                return None, f"❌ That picture is {human_size(size)}; I can read pictures up to {human_size(RESIZE_MAX_BYTES)}."
+            raw = await self.client.download_media(msg, file=bytes)
+        elif getattr(msg, "document", None) is not None:
+            raw = await self.client.download_media(msg, file=bytes, thumb=-1)
         else:
-            await event.answer()
+            return None, "❌ There's no picture in that."
+        return (raw, "") if raw else (None, "❌ I couldn't get a picture from that.")
 
-    async def _on_resize_text(self, event: Any, p: Pending) -> None:
-        uid = event.sender_id
-        box = media.parse_size(event.raw_text or "")
-        if box is None:
-            await self._reply(
-                event, "❌ I couldn't read that size. Send it like <code>320x180</code> or <code>320</code> (16 to 4096 pixels).\n\nTry again, or tap Cancel."
-            )
+    async def _remove_later(self, chat_id: int, msg_id: int, seconds: float) -> None:
+        await asyncio.sleep(seconds)
+        await self._delete_quietly(chat_id, msg_id)
+
+    async def cmd_size(self, event: Any) -> None:
+        """Reply to a picture (or to anything with a preview) with /size: how many pixels wide and high it is."""
+        reply = await event.get_reply_message()
+        if reply is None or not reply.media:
+            await self._reply(event, "Reply to a picture or other media with /size to get its dimensions.")
+            return
+        status = await self._reply(event, "⏳ Processing…")
+        raw, why = await self._picture_of(reply)
+        if raw is None:
+            await self.client.edit_message(status, why, parse_mode="html")
             return
-        self.pending.pop(uid, None)
-        mode = self._start_mode(uid, "resize", ONE_FILE_WAIT, {"box": box})
-        try:
-            await event.delete()
-        except Exception:  # noqa: BLE001
-            pass
-        text, rows = panels.resize_ready(box, ONE_FILE_WAIT // 60)
-        text += f"\n\n{mode.dropped}" if mode.dropped else ""
         try:
-            await self.client.edit_message(p.chat_id, p.msg_id, text, buttons=panels.to_buttons(rows), parse_mode="html")
+            width, height = await asyncio.to_thread(media.image_size, raw)
         except Exception:  # noqa: BLE001
-            await self._reply(event, text, rows)
-
-    async def _image_mode(self, event: Any) -> bool:
-        """Give an incoming picture (or GIF) to the command that is waiting for one (/resize, /smedia).  True when the message was taken care of."""
-        uid = event.sender_id
-        mode = self._mode(uid, "resize", "smedia")
-        if mode is None:
-            return False
-        if mode.kind == "smedia":
-            await self._take_start_media(event, mode)
-            return True
-        if not is_image(event.message):
-            await self._reply(event, "❌ That isn't an image. Send a photo or an image file, or /cancel to stop.")
-            return True
-        self._consume(uid, "resize")
-        await self._send_resized(event, event.message, mode.data["box"])
-        return True
+            await self.client.edit_message(status, "❌ I couldn't read that image.", parse_mode="html")
+            return
+        await self.client.edit_message(status, f"Dimension Of This Image Is\n<code>{width} x {height}</code>", parse_mode="html")
 
-    async def _send_resized(self, event: Any, msg: Any, box: Any) -> None:
-        size = int(msg.file.size or 0) if getattr(msg, "file", None) is not None else 0
-        if size > RESIZE_MAX_BYTES:
-            await self._reply(event, f"❌ That image is {human_size(size)}; I can resize images up to {human_size(RESIZE_MAX_BYTES)}.")
+    async def cmd_resize(self, event: Any) -> None:
+        """Reply to a picture with ``/resize 720 1080``: it comes back at exactly that many pixels wide and high (its shape is not kept)."""
+        reply = await event.get_reply_message()
+        if reply is None or not reply.media:
+            await self._reply(event, "Reply to a picture or other media with /resize and a size, like <code>/resize 720 1080</code>.")
             return
-        raw = await self.client.download_media(msg, file=bytes)
-        if not raw:
-            await self._reply(event, "❌ I couldn't download that image.")
+        sides = self._args(event).split()
+        if len(sides) != 2 or not all(re.fullmatch(r"[0-9]{1,6}", side) for side in sides):
+            hint = await self._reply(event, "Give Some Size To Resize, Like <code>/resize 720 1080</code>")
+            self._spawn(self._remove_later(event.chat_id, hint.id, HINT_SECONDS))  # it goes away by itself
+            return
+        width, height = int(sides[0]), int(sides[1])
+        if not (1 <= width <= RESIZE_MAX_SIDE and 1 <= height <= RESIZE_MAX_SIDE):
+            await self._reply(event, f"❌ Each side can be 1 to {RESIZE_MAX_SIDE} pixels, like <code>/resize 720 1080</code>.")
+            return
+        status = await self._reply(event, "⏳ Processing…")
+        raw, why = await self._picture_of(reply)
+        if raw is None:
+            await self.client.edit_message(status, why, parse_mode="html")
             return
         try:
-            data, original, new = await asyncio.to_thread(media.resize_image, raw, box[0], box[1])
+            data = await asyncio.to_thread(media.resize_exact, raw, width, height)
+        except media.ImageTooBig:
+            await self.client.edit_message(status, "❌ That picture has too many pixels for me to resize.", parse_mode="html")
+            return
         except Exception:  # noqa: BLE001
-            await self._reply(event, "❌ I couldn't read that image.")
+            await self.client.edit_message(status, "❌ I couldn't read that image.", parse_mode="html")
             return
         bio = io.BytesIO(data)
-        bio.name = "resized.jpg"
-        caption = f"🖼 <b>{new[0]}×{new[1]}</b> (was {original[0]}×{original[1]}) · {human_size(len(data))}"
-        await self.client.send_file(event.chat_id, bio, caption=caption, parse_mode="html", force_document=max(new) > 1280)
+        bio.name = "resized.png"
+        try:  # as a photo when Telegram keeps it as it is, otherwise as a file, so the size stays exact
+            await event.reply(file=bio, force_document=not fits_as_photo(width, height, len(data)))
+        except Exception:  # noqa: BLE001
+            log.exception("could not send the resized picture")
+            await self.client.edit_message(status, "❌ Telegram wouldn't take the resized picture.", parse_mode="html")
+            return
+        await self._delete_quietly(event.chat_id, status.id)
 
     # ------------------------------------------------------- /smedia, the /start picture
     async def _start_media_meta(self) -> Optional[Dict[str, Any]]:
@@ -1508,11 +1448,7 @@ class App:
         if p.kind.startswith("fmt:"):
             await self._on_format_text(event, p)
             return
-        if p.kind == "resize:size":
-            await self._on_resize_text(event, p)
-            return
-        value = self._caption_input(event) if p.kind == "caption" else event.raw_text
-        ok, msg = await apply_setting(self._store(p.kind), uid, p.kind, value)
+        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.")
             return
@@ -1576,10 +1512,6 @@ class App:
             await self._cb_sequence(event, uid, parts)
             return
 
-        if head == "rz":
-            await self._cb_resize(event, uid, parts)
-            return
-
         if head == "sm":
             await self._cb_smedia(event, uid, parts)
             return
@@ -1595,45 +1527,13 @@ class App:
             await self._cb_input(event, uid, parts)
             return
 
-        if head == "clr" and len(parts) == 2:
-            if parts[1] == "caption":
-                _ok, msg = await apply_setting(self._store("caption"), uid, "caption", "reset")
-                panel = "cap"
-            elif parts[1] in ("keep_audio", "keep_subtitle"):
-                _ok, msg = await apply_setting(self.db, uid, parts[1], "off")
-                panel = "tool"
-            else:
-                await event.answer()
-                return
-            text, rows = await self.panel(uid, panel)
+        if head == "clr" and len(parts) == 2 and parts[1] in ("keep_audio", "keep_subtitle"):
+            _ok, msg = await apply_setting(self.db, uid, parts[1], "off")
+            text, rows = await self.panel(uid, "tool")
             await self._edit_panel(event, text, rows)
             await event.answer(clip(plain(msg), 190))
             return
 
-        if head == "th" and len(parts) in (2, 3) and parts[1] in ("del", "rm", "view") and (len(parts) == 2 or parts[2].isdigit()):
-            fid = int(parts[2]) if len(parts) == 3 else None  # the format the button belongs to (none: older buttons, the one in use)
-            if fid is not None and await self._thumb_format(uid, fid) is None:
-                await event.answer("That format no longer exists.", alert=True)
-                return
-            if parts[1] in ("del", "rm"):
-                await self._delete_auto_thumb(uid, fid)
-                if parts[1] == "rm":  # button on a standalone thumbnail message
-                    await event.answer("Thumbnail deleted.")
-                    await self._remove_message(event)
-                else:  # button inside the Caption & Thumbnail panel
-                    text, rows = await self.panel(uid, "cap")
-                    await self._edit_panel(event, text, rows)
-                    await event.answer("Thumbnail deleted.")
-                return
-            if parts[1] == "view":
-                auto, data_bytes = await self._auto_thumb(uid, fid)
-                if not data_bytes:
-                    await event.answer("Your auto format has no thumbnail yet — send me a photo.", alert=True)
-                    return
-                await event.answer()
-                await self._send_thumb(event.chat_id, data_bytes, auto["id"])
-                return
-
         if data == "help:meta":
             text, rows = panels.metadata_help()
             await self._edit_panel(event, text, rows)

bot/db.py

@@ -5,7 +5,6 @@ external Postgres (Neon, Supabase, ...).  SQLite works for local testing.
 """
 from __future__ import annotations
 
-import asyncio
 import copy
 import json
 import os
@@ -218,7 +217,6 @@ class Database:
         self.engine: AsyncEngine = create_async_engine(self.url, pool_pre_ping=True, connect_args=connect_args)
         self._sessions = async_sessionmaker(self.engine, expire_on_commit=False)
         self._cache: Dict[int, Dict[str, Any]] = {}
-        self._default_locks: Dict[int, asyncio.Lock] = {}
 
     async def init(self) -> None:
         async with self.engine.begin() as conn:
@@ -527,20 +525,6 @@ class Database:
         await self.update_settings(uid, auto_format=fid)
         return fmt
 
-    async def ensure_auto_format(self, uid: int) -> Dict[str, Any]:
-        """The auto format in use; the first time there is none, a format called "Default" is made and used.
-
-        That is what lets the Template and Caption buttons and a thumbnail photo work for someone who never made a format.  Several photos
-        sent at once ask for it at the same moment, so one user is served at a time: the first makes it, the others find it.
-        """
-        async with self._default_locks.setdefault(uid, asyncio.Lock()):
-            fmt = await self.get_auto_format(uid)
-            if fmt is not None:
-                return fmt
-            fmt = await self.create_format(uid, MIGRATED_FORMAT_NAME, kind="auto")
-            await self.update_settings(uid, auto_format=fmt["id"])
-            return fmt
-
     # ----- admins ------------------------------------------------------------------
     async def list_admins(self) -> List[int]:
         async with self._sessions() as session:

bot/formats.py

@@ -118,23 +118,3 @@ class FormatSettings:
         if wanted and await self.db.update_format(uid, self.fid, **wanted) is None:
             raise LookupError("that format no longer exists")
         return await self.get_settings(uid)
-
-
-class AutoFormatSettings:
-    """The auto format in use, edited the way a setting is: the Template and Caption buttons go through here.
-
-    A user who has no auto format gets one called "Default" the first time they change something.
-    """
-
-    def __init__(self, db: Database):
-        self.db = db
-
-    async def get_settings(self, uid: int) -> Dict[str, Any]:
-        return _as_settings(await self.db.get_auto_format(uid) or default_auto_format())
-
-    async def update_settings(self, uid: int, **changes: Any) -> Dict[str, Any]:
-        wanted = {k: v for k, v in changes.items() if k in _EDITABLE}
-        fmt = await self.db.ensure_auto_format(uid)
-        if wanted:
-            fmt = await self.db.update_format(uid, fmt["id"], **wanted) or fmt
-        return _as_settings(fmt)

bot/media.py

@@ -432,25 +432,6 @@ async def extract_frame(
     return False
 
 
-SIZE_MIN, SIZE_MAX = 16, 4096
-THUMB_BOX = 320  # Telegram shows custom thumbnails up to 320 px, as a JPEG under 200 KB
-
-
-_SIZE_RE = re.compile(r"\s*(\d{1,5})(?:(?:\s*[x×*,:]\s*|\s+)(\d{1,5}))?\s*", re.I)
-
-
-def parse_size(text: str) -> Optional[Tuple[int, int]]:
-    """``320`` -> (320, 320); ``320x180`` / ``320×180`` / ``320 180`` -> (320, 180); None when it isn't a usable size."""
-    m = _SIZE_RE.fullmatch(text or "")
-    if not m:
-        return None
-    width = int(m.group(1))
-    height = int(m.group(2)) if m.group(2) else width
-    if not (SIZE_MIN <= width <= SIZE_MAX and SIZE_MIN <= height <= SIZE_MAX):
-        return None
-    return width, height
-
-
 def _flatten(img: Any) -> Any:
     """``img`` as RGB; transparent parts become white."""
     from PIL import Image
@@ -475,25 +456,39 @@ def fit_photo(data: bytes, box: int = 1280) -> bytes:
         return buf.getvalue()
 
 
-def resize_image(data: bytes, width: int, height: int) -> Tuple[bytes, Tuple[int, int], Tuple[int, int]]:
-    """Scale an image to fit inside ``width`` x ``height``, keeping its shape.
+RESIZE_MAX_PIXELS = 80_000_000  # a picture with more pixels than this is not resized (it would take gigabytes of memory)
+_PNG_FRIENDLY_MODES = ("L", "LA", "RGB", "RGBA")  # the rest (palettes, CMYK ...) is converted so it resizes smoothly and saves as PNG
 
-    Returns ``(jpeg bytes, original size, new size)``.  A result that fits Telegram's thumbnail box stays under 200 KB.
-    """
+
+class ImageTooBig(ValueError):
+    """A picture has more than ``RESIZE_MAX_PIXELS`` pixels."""
+
+
+def image_size(data: bytes) -> Tuple[int, int]:
+    """``(width, height)`` of a picture, the way it is meant to be seen (a photo stored sideways is counted as turned upright)."""
+    from PIL import Image
+
+    with Image.open(io.BytesIO(data)) as img:
+        width, height = img.size
+        if img.getexif().get(0x0112, 1) in (5, 6, 7, 8):  # EXIF orientation: turned a quarter
+            width, height = height, width
+        return width, height
+
+
+def resize_exact(data: bytes, width: int, height: int) -> bytes:
+    """The picture scaled to exactly ``width`` x ``height`` pixels, whatever its shape, as an optimised PNG."""
     from PIL import Image, ImageOps
 
     with Image.open(io.BytesIO(data)) as img:
+        if img.width * img.height > RESIZE_MAX_PIXELS:
+            raise ImageTooBig(f"{img.width}x{img.height} pixels")
         img = ImageOps.exif_transpose(img)
-        original = img.size
-        img = _flatten(img)
-        out = ImageOps.contain(img, (width, height), Image.LANCZOS)
-        limit = 200 * 1024 if max(out.size) <= THUMB_BOX else None
-        for quality in (92, 85, 78, 70, 60, 50, 40):
-            buf = io.BytesIO()
-            out.save(buf, "JPEG", quality=quality, optimize=True)
-            if limit is None or buf.tell() <= limit:
-                break
-        return buf.getvalue(), original, out.size
+        if img.mode not in _PNG_FRIENDLY_MODES:
+            img = img.convert("RGBA" if "A" in img.getbands() or "transparency" in img.info else "RGB")
+        out = img.resize((width, height))
+        buf = io.BytesIO()
+        out.save(buf, format="PNG", optimize=True)
+        return buf.getvalue()
 
 
 def prepare_thumb(data: bytes) -> bytes:

bot/panels.py

@@ -110,9 +110,8 @@ def home(s: Dict[str, Any], *, owner: bool, auto: Optional[Dict[str, Any]] = Non
     )
     rows: List[Row] = [
         [("Auto Format", "m:auto"), ("Rename", "m:rename")],
-        [("Caption & Thumbnail", "m:cap"), ("Metadata", "m:meta")],
-        [("File Type", "m:ftype"), ("Formats", "m:formats")],
-        [("Help", "m:help")] + ([("Admin", "m:admin")] if owner else []),
+        [("Metadata", "m:meta"), ("File Type", "m:ftype")],
+        [("Formats", "m:formats"), ("Help", "m:help")] + ([("Admin", "m:admin")] if owner else []),
         [("✖ Close", "x:close")],
     ]
     return text, rows
@@ -127,32 +126,13 @@ def rename(s: Dict[str, Any], auto: Optional[Dict[str, Any]] = None) -> Panel:
         f"Current mode: <code>{s['mode'].upper()}</code>\n"
         "Command: /mode\n\n"
         f"<b>Template</b> of the auto format {_auto_name(auto)}: {_code(_template_of(auto), 120)}\n"
+        "Change it in /formats.\n\n"
         f"<b>Remove words:</b> {esc(clip(words, 100))}"
     )
     rows: List[Row] = [
         [(_check("Filename", s["mode"] == "filename"), "set:mode:filename"),
          (_check("Caption", s["mode"] == "caption"), "set:mode:caption")],
-        [("Template", "in:template"), ("Remove words", "in:remove")],
-    ] + nav("home")
-    return text, rows
-
-
-def caption(auto: Optional[Dict[str, Any]], has_thumb: bool) -> Panel:
-    """The caption and thumbnail of the auto format in use (``None``: the user has none, the default caption is shown)."""
-    text = (
-        "<b>CAPTION &amp; THUMBNAIL</b>\n"
-        f"Of the auto format {_auto_name(auto)}\n\n"
-        f"<b>Caption template:</b> {richtext.preview(auto['caption'] if auto else DEFAULT_CAPTION, 160)}\n"
-        f"Variables: {CAPTION_VARIABLES}\n"
-        "Tap Set Caption and format it the way you do in any message (<b>bold</b>, <i>italic</i>, links…): "
-        "I keep it exactly like that.\n\n"
-        f"<b>Thumbnail:</b> {'✅ saved' if has_thumb else '❌ none (a frame of the video is used)'}\n"
-        "Send me a photo to set the thumbnail."
-    )
-    thumb = f":{auto['id']}" if auto else ""  # the thumbnail buttons name the format the panel was drawn for
-    rows: List[Row] = [
-        [("Set Caption", "in:caption"), ("Reset Caption", "clr:caption")],
-        [("View Thumb", f"th:view{thumb}"), ("Delete Thumb", f"th:del{thumb}")],
+        [("Remove words", "in:remove")],
     ] + nav("home")
     return text, rows
 
@@ -235,15 +215,14 @@ def help_panel() -> Panel:
         "<b>How to use</b>\n\n"
         "1. Send a file — I rename it with your <b>auto format</b> (pick it in the /start menu) and send it back.\n"
         "2. /rename — one file with a <b>manual format</b>: pick one, then send the file.\n"
-        "3. /formats — 12 auto and 12 manual formats (template, caption, thumbnail, metadata): edit, copy between kinds, share.\n"
-        "4. /start → Rename, Caption &amp; Thumbnail — edit your auto format.\n"
-        "5. /mode — read details from the file name or the caption.\n"
-        "6. /metadata, /keepaudio, /keepsubtitle — default metadata and tracks (formats can copy it).\n"
-        "7. /filetype — send as document, video or audio.\n"
-        "8. Send a photo — the thumbnail of your auto format.\n"
-        "9. /sequence then /sort — put files in episode order.\n"
-        "10. /check, /mediainfo, /ethumb, /resize, /speed — inspect files and images.\n"
-        "11. /queue and /cancel — manage jobs.\n\n"
+        "3. /formats — 12 auto and 12 manual formats. A format holds the template, caption, thumbnail and metadata: edit, copy between kinds, share.\n"
+        "4. /mode — read details from the file name or the caption.\n"
+        "5. /metadata, /keepaudio, /keepsubtitle — default metadata and tracks (formats can copy it).\n"
+        "6. /filetype — send as document, video or audio.\n"
+        "7. /sequence then /sort — put files in episode order.\n"
+        "8. /check, /mediainfo, /ethumb, /speed — inspect files.\n"
+        "9. /size and /resize (reply to a picture) — its dimensions, or a copy at an exact size.\n"
+        "10. /queue and /cancel — manage jobs.\n\n"
         f"Template variables: {TEMPLATE_VARIABLES}\n"
         "A [bracket] group is dropped when a variable inside it is empty."
     )
@@ -532,42 +511,6 @@ def ethumb_prompt(minutes: int) -> Panel:
     return text, [[("⏹ Stop", "et:stop")]]
 
 
-RESIZE_PRESETS = ((320, "Thumbnail · 320 px"), (640, "640 px"), (1280, "1280 px"))
-
-
-def describe_box(box: Tuple[int, int]) -> str:
-    width, height = box
-    return f"{width} px" if width == height else f"{width}×{height}"
-
-
-def resize_menu() -> Panel:
-    text = (
-        "<b>🖼 RESIZE IMAGE</b>\n\n"
-        "Choose the size. The picture keeps its shape and fits inside it, and comes back as a JPEG. "
-        "Thumbnail size (320 px) stays under 200 KB, which is what Telegram accepts.\n\n"
-        "Or send the size with the command, like <code>/resize 320x180</code>."
-    )
-    rows: List[Row] = [[(label, f"rz:s:{side}")] for side, label in RESIZE_PRESETS]
-    rows.append([("✏️ Custom size", "rz:custom")])
-    return text, rows + [[("✖ Close", "x:close")]]
-
-
-def resize_ready(box: Tuple[int, int], minutes: int) -> Panel:
-    text = (
-        f"✅ Size: <b>{describe_box(box)}</b>\n\n"
-        "Now send me the image (a photo, or an image sent as a file). I'll resize it and send it back.\n"
-        "It works for one image at a time: for another, send /resize again.\n"
-        f"I'll wait {minutes} minutes. /cancel to stop."
-    )
-    return text, [[("🔄 Change size", "rz:menu"), ("⏹ Stop", "rz:stop")]]
-
-
-RESIZE_CUSTOM_PROMPT = (
-    "<b>Send the size</b> as width and height, like <code>320x180</code>, or one number like <code>320</code> "
-    "for a square box (16 to 4096 pixels). The picture keeps its shape and fits inside the box."
-)
-
-
 def smedia_menu(current: str) -> Panel:
     """/smedia: ``current`` is what /start shows above the menu now: ``image``, ``gif`` or ``""`` (nothing)."""
     shown = {"image": "an image", "gif": "a GIF"}.get(current, "nothing, just the menu")
@@ -617,20 +560,6 @@ def sequence_status(count: int, limit: int) -> Panel:
 # ---------------------------------------------------------------------------
 
 PROMPTS: Dict[str, str] = {
-    "template": (
-        "<b>Send the new filename template.</b>\n\n"
-        f"Variables: {TEMPLATE_VARIABLES}\n"
-        f"{EPISODE_ZEROS}\n"
-        "A [bracket] or (paren) group disappears when a variable inside it is empty.\n"
-        "If only an episode number is found, the season defaults to 01.\n\n"
-        "Example: <code>[S{season}E{episode}] {title} [{quality}]</code>"
-    ),
-    "caption": (
-        "<b>Send the new caption template.</b>\n\n"
-        f"Variables: {CAPTION_VARIABLES}\n"
-        "Format it the way you do in any message (<b>bold</b>, <i>italic</i>, links…) and I'll keep it exactly like that. "
-        "No HTML needed."
-    ),
     "remove": (
         "<b>Send the words to strip from names.</b>\n\n"
         "Separate them with commas, e.g. <code>@SomeChannel, [Group], www.site.com</code>\n"
@@ -665,7 +594,14 @@ FORMAT_PROMPTS: Dict[str, str] = {
     "new": "<b>Send a name for the new format</b>, like <code>One Piece</code> or <code>Dragon Ball</code> (30 characters max).",
     "name": "<b>Send the new name</b> for this format (30 characters max).",
     "thumb": "<b>Send a photo</b> to use as this format's thumbnail.",
-    "template": PROMPTS["template"],
+    "template": (
+        "<b>Send the new filename template.</b>\n\n"
+        f"Variables: {TEMPLATE_VARIABLES}\n"
+        f"{EPISODE_ZEROS}\n"
+        "A [bracket] or (paren) group disappears when a variable inside it is empty.\n"
+        "If only an episode number is found, the season defaults to 01.\n\n"
+        "Example: <code>[S{season}E{episode}] {title} [{quality}]</code>"
+    ),
     "caption": (
         "<b>Send the caption for this format.</b>\n\n"
         f"Variables: {CAPTION_VARIABLES}\n"

bot/settings_ops.py

@@ -3,8 +3,8 @@
 Used by both the slash commands and the inline "send me the value" flow, so the
 two can never disagree.  Functions return ``(ok, html_message)``.
 
-``db`` is whatever keeps the setting: the ``Database`` for the user's own settings, a ``FormatSettings`` for a saved format and an
-``AutoFormatSettings`` for the auto format in use (the template and the caption live in formats, not in the user's settings).
+``db`` is whatever keeps the setting: the ``Database`` for the user's own settings, a ``FormatSettings`` for a saved format
+(the template and the caption live in formats, not in the user's settings).
 """
 from __future__ import annotations
 

tests/appkit.py

@@ -79,16 +79,21 @@ async def auto_thumb(ctx, uid=OWNER):
     return await ctx.db.get_format_thumb(uid, fmt["id"]) if fmt is not None and fmt["has_thumb"] else None
 
 
+async def ensure_auto(db, uid=OWNER):
+    """The user's auto format, made first (a format called "Default") when they have none: what the tests build on."""
+    return await db.get_auto_format(uid) or await db.create_format(uid, "Default", kind="auto")
+
+
 async def set_auto_thumb(ctx, data, uid=OWNER):
     """Give the user's auto format a thumbnail, making the "Default" auto format first if they have none."""
-    fmt = await ctx.db.ensure_auto_format(uid)
+    fmt = await ensure_auto(ctx.db, uid)
     await ctx.db.set_format_thumb(uid, fmt["id"], data)
     return fmt
 
 
 async def edit_auto(ctx, uid=OWNER, **changes):
     """Change the user's auto format (``template=...``, ``caption=...``), making the "Default" one first if they have none."""
-    fmt = await ctx.db.ensure_auto_format(uid)
+    fmt = await ensure_auto(ctx.db, uid)
     return await ctx.db.update_format(uid, fmt["id"], **changes)
 
 

tests/test_app.py

@@ -118,7 +118,8 @@ async def test_start_shows_the_home_panel_and_hides_admin_from_admins(ctx):
     ev = await say(ctx, OWNER, "/start")
     text, buttons, kw = ev.out[0]
     assert "Auto Rename Bot" in text and kw["parse_mode"] == "html"
-    assert {"m:auto", "m:rename", "m:cap", "m:meta", "m:ftype", "m:formats", "m:help", "m:admin"} <= set(data_of(buttons))
+    assert {"m:auto", "m:rename", "m:meta", "m:ftype", "m:formats", "m:help", "m:admin"} <= set(data_of(buttons))
+    assert "m:cap" not in data_of(buttons)  # the caption and the thumbnail are edited in /formats
     assert "m:admin" not in data_of((await say(ctx, ADMIN_CFG, "/start")).out[0][1])
 
 
@@ -128,7 +129,7 @@ async def test_start_variants(ctx, text):
 
 
 async def test_start_and_help(ctx):
-    ctx.app.pending[OWNER] = Pending("template", OWNER, 1, "rename", False, time.time() + 100)
+    ctx.app.pending[OWNER] = Pending("remove", OWNER, 1, "rename", False, time.time() + 100)
     await say(ctx, OWNER, "/start")
     assert OWNER not in ctx.app.pending
     ev = await say(ctx, OWNER, "/help")
@@ -166,20 +167,17 @@ async def test_metadata_command(ctx):
     assert "currently: Off" in ev.texts[0]
 
 
-async def test_the_template_and_caption_buttons_edit_the_auto_format_and_make_it_when_needed(ctx):
-    assert await autofmt(ctx) is None
-    await click(ctx, OWNER, "in:template", msg_id=500)
-    assert await autofmt(ctx) is None  # only opening the prompt: no format is made
-
+async def test_the_template_and_caption_of_the_auto_format_are_edited_in_its_formats_screen(ctx):
+    auto = await ctx.db.create_format(OWNER, "Mine", kind="auto")
+    fid = auto["id"]
+    await click(ctx, OWNER, f"fm:in:{fid}:template", msg_id=500)
     await say(ctx, OWNER, "[S{season}E{episode}] {title} [{quality}]", mid=60)
     assert "Template saved" in ctx.client.edited[-1][1]
-    auto = await autofmt(ctx)  # it is the template of the auto format in use, made on the first change
-    assert auto["name"] == "Default" and auto["kind"] == "auto"
-    assert auto["template"] == "[S{season}E{episode}] {title} [{quality}]"
+    assert (await autofmt(ctx))["template"] == "[S{season}E{episode}] {title} [{quality}]"
     assert "template" not in await prefs(ctx) and "caption" not in await prefs(ctx)
-    assert "[S{season}E{episode}] {title} [{quality}]" in (await click(ctx, OWNER, "m:rename")).edits[-1][0]
+    assert "[S{season}E{episode}] {title} [{quality}]" in (await click(ctx, OWNER, "m:rename")).edits[-1][0]  # shown there, not edited
 
-    await click(ctx, OWNER, "in:caption", msg_id=501)
+    await click(ctx, OWNER, f"fm:in:{fid}:caption", msg_id=501)
     await say(ctx, OWNER, "<b>{filename}</b> {size}", mid=61)
     assert (await autofmt(ctx))["caption"] == "<b>{filename}</b> {size}"
     assert await ctx.db.count_formats(OWNER) == 1  # both went into the same format
@@ -204,9 +202,10 @@ async def test_removewords_command(ctx):
 
 
 async def test_template_and_caption_prompts_list_each_variable_as_its_own_copyable_block(ctx):
-    line, blocks = variables_line((await click(ctx, OWNER, "in:template")).edits[-1][0])
+    fid = (await ctx.db.create_format(OWNER, "Mine", kind="auto"))["id"]
+    line, blocks = variables_line((await click(ctx, OWNER, f"fm:in:{fid}:template")).edits[-1][0])
     assert blocks == line.split(": ", 1)[1].split() and "{quality}" in blocks and "{3episode}" in blocks and "{4episode}" not in blocks and len(blocks) == 11
-    line, blocks = variables_line((await click(ctx, OWNER, "in:caption")).edits[-1][0])
+    line, blocks = variables_line((await click(ctx, OWNER, f"fm:in:{fid}:caption")).edits[-1][0])
     assert blocks == line.split(": ", 1)[1].split() and "{size}" in blocks and "{3episode}" in blocks and "{4episode}" not in blocks and len(blocks) == 13
 
 
@@ -270,126 +269,63 @@ async def test_setchannel(ctx):
 # ---------------------------------------------------------------------------
 
 
-async def test_photo_becomes_the_thumbnail_of_the_auto_format_and_can_be_viewed_and_deleted(ctx):
-    cb = await click(ctx, OWNER, "th:view")
-    assert cb.alerts and "no thumbnail" in cb.alerts[0] and await autofmt(ctx) is None
-    ev = FakeEvent(OWNER, message=FakeMessage("", mid=20, photo=True), photo_bytes=jpeg())
+async def send_photo(ctx, mid=20, sender=OWNER, data=None, **kw):
+    ev = FakeEvent(sender, message=FakeMessage("", mid=mid, photo=True, **kw), photo_bytes=jpeg() if data is None else data)
     await dispatch(ctx.client, ev)
-    assert "Thumbnail saved" in ev.texts[0] and "auto format" in ev.texts[0]
-    auto = await autofmt(ctx)  # the first photo makes the auto format "Default" (like the first template change does)
-    assert auto["name"] == "Default" and auto["has_thumb"]
-    assert f"th:rm:{auto['id']}" in data_of(ev.out[0][1])  # the button names the format whose thumbnail it deletes
-    stored = await auto_thumb(ctx)
-    assert stored[:2] == b"\xff\xd8"
-    assert await auto_thumb(ctx, ADMIN_CFG) is None and await autofmt(ctx, ADMIN_CFG) is None  # per user
-
-    await click(ctx, OWNER, "th:view")
-    (chat, file, kw), = ctx.client.files
-    assert chat == OWNER and file.read() == stored and f"th:rm:{auto['id']}" in data_of(kw["buttons"])
-
-    cb = await click(ctx, OWNER, f"th:del:{auto['id']}")  # Delete Thumb in the Caption & Thumbnail panel
-    assert await auto_thumb(ctx) is None and (await autofmt(ctx))["id"] == auto["id"]  # the format stays
-    assert "none" in cb.edits[-1][0] and cb.toasts == ["Thumbnail deleted."]
-    cb = await click(ctx, OWNER, "th:view")
-    assert cb.alerts and "no thumbnail" in cb.alerts[0]
-
-
-async def test_a_photo_goes_to_the_auto_format_in_use_and_never_to_a_manual_one(ctx):
-    one = await ctx.db.create_format(OWNER, "One", kind="auto")
-    two = await ctx.db.create_format(OWNER, "Two", kind="auto")
-    manual = await ctx.db.create_format(OWNER, "Manual", kind="manual")
-    await ctx.db.select_auto_format(OWNER, two["id"])
-    ev = FakeEvent(OWNER, message=FakeMessage("", mid=20, photo=True), photo_bytes=jpeg())
-    await dispatch(ctx.client, ev)
-    assert "<b>Two</b>" in ev.texts[0]
-    assert await ctx.db.get_format_thumb(OWNER, two["id"]) and await ctx.db.get_format_thumb(OWNER, one["id"]) is None
-    assert await ctx.db.get_format_thumb(OWNER, manual["id"]) is None
-
+    return ev
 
-async def test_several_photos_at_once_from_someone_with_no_auto_format_all_work(ctx):
-    events = [FakeEvent(OWNER, message=FakeMessage("", mid=20 + i, photo=True), photo_bytes=jpeg()) for i in range(3)]
-    await asyncio.gather(*(dispatch(ctx.client, ev) for ev in events))
-    assert all("Thumbnail saved" in ev.texts[0] for ev in events)  # none of them failed on the format the first one made
-    (auto,) = await ctx.db.list_formats(OWNER, "auto")
-    assert auto["name"] == "Default" and auto["has_thumb"] and (await prefs(ctx))["auto_format"] == auto["id"]
 
+async def test_a_photo_sent_or_forwarded_to_the_bot_is_not_made_a_thumbnail(ctx):
+    ev = await send_photo(ctx)
+    assert ev.out == [] and ctx.client.files == [] and ctx.client.edited == []  # no answer, nothing saved
+    assert await ctx.db.count_formats(OWNER) == 0  # not even a format was made for it
 
-async def test_unreadable_photos_are_reported(ctx):
-    ev = FakeEvent(OWNER, message=FakeMessage("", photo=True), photo_bytes=b"not an image")
-    await dispatch(ctx.client, ev)
-    assert "couldn't read" in ev.texts[0]
-    ev = FakeEvent(OWNER, message=FakeMessage("", photo=True), photo_bytes=None)
-    await dispatch(ctx.client, ev)
-    assert "couldn't download" in ev.texts[0]
-    assert await autofmt(ctx) is None  # nothing was saved, not even a format
-    stranger = FakeEvent(STRANGER, message=FakeMessage("", photo=True), photo_bytes=jpeg())
-    await dispatch(ctx.client, stranger)
+    auto = await ctx.db.create_format(OWNER, "Auto", kind="auto")
+    manual = await ctx.db.create_format(OWNER, "Manual", kind="manual")
+    assert (await send_photo(ctx, 21)).out == []
+    assert (await send_photo(ctx, 22, fwd=True)).out == []  # a forwarded one is no different
+    assert await ctx.db.get_format_thumb(OWNER, auto["id"]) is None and await ctx.db.get_format_thumb(OWNER, manual["id"]) is None
+    assert not (await autofmt(ctx))["has_thumb"] and ctx.client.files == []
+
+
+async def test_only_the_thumbnail_prompt_of_a_format_takes_a_photo(ctx):
+    auto = await ctx.db.create_format(OWNER, "Auto", kind="auto")
+    for kind in ("remove", "mt_title", "keep_audio"):  # no other prompt takes it
+        ctx.app.pending[OWNER] = Pending(kind, OWNER, 1, "rename", False, time.time() + 100)
+        assert (await send_photo(ctx)).out == [] and ctx.app.pending[OWNER].kind == kind
+    ctx.app.pending[OWNER] = Pending("fmt:template", OWNER, 1, "formats", False, time.time() + 100, fid=auto["id"])
+    assert (await send_photo(ctx)).out == [] and ctx.app.pending[OWNER].kind == "fmt:template"
+    ctx.app.pending[OWNER] = Pending("fmt:thumb", OWNER, 1, "formats", False, time.time() - 1, fid=auto["id"])  # one that ran out
+    assert (await send_photo(ctx)).out == []
+    assert await ctx.db.get_format_thumb(OWNER, auto["id"]) is None
+
+    ctx.app.pending[OWNER] = Pending("fmt:thumb", OWNER, 500, "formats", False, time.time() + 100, fid=auto["id"])
+    await send_photo(ctx, 30)  # the one that is waiting for it does
+    assert (await ctx.db.get_format_thumb(OWNER, auto["id"]))[:2] == b"\xff\xd8" and OWNER not in ctx.app.pending
+
+
+async def test_unreadable_photos_are_reported_while_a_format_waits_for_its_thumbnail(ctx):
+    auto = await ctx.db.create_format(OWNER, "Auto", kind="auto")
+    for data, said in ((b"not an image", "couldn't read"), (None, "couldn't download")):
+        ctx.app.pending[OWNER] = Pending("fmt:thumb", OWNER, 500, "formats", False, time.time() + 100, fid=auto["id"])
+        ev = FakeEvent(OWNER, message=FakeMessage("", photo=True), photo_bytes=data)
+        await dispatch(ctx.client, ev)
+        assert said in ev.texts[0] and OWNER in ctx.app.pending  # and the prompt stays open for another try
+    assert await ctx.db.get_format_thumb(OWNER, auto["id"]) is None
+    stranger = await send_photo(ctx, sender=STRANGER)
     assert stranger.out == [] and await autofmt(ctx, STRANGER) is None
 
 
-async def test_thumbnail_buttons_of_older_messages_have_no_format_and_use_the_one_in_use(ctx):
-    cb = await click(ctx, OWNER, "th:view")
-    assert cb.alerts and "no thumbnail" in cb.alerts[0]
-    await set_auto_thumb(ctx, b"\xff\xd8thumb")
-    cb = await click(ctx, OWNER, "th:view")
-    assert cb.answers == [(None, False)] and len(ctx.client.files) == 1
-
-    cb = await click(ctx, OWNER, "th:del")  # inside the Caption & Thumbnail panel
-    assert await auto_thumb(ctx) is None and "CAPTION" in cb.edits[-1][0] and "none" in cb.edits[-1][0]
-    assert cb.toasts == ["Thumbnail deleted."] and not cb.deleted
-
-    await set_auto_thumb(ctx, b"\xff\xd8thumb")
-    cb = await click(ctx, OWNER, "th:rm")  # under a standalone thumbnail message
-    assert await auto_thumb(ctx) is None and cb.deleted and cb.edits == []
-
-
-async def test_thumbnail_buttons_name_their_format_so_an_old_message_never_hits_another_one(ctx):
-    one = await ctx.db.create_format(OWNER, "One", kind="auto")
-    two = await ctx.db.create_format(OWNER, "Two", kind="auto")
-    await ctx.db.set_format_thumb(OWNER, one["id"], b"\xff\xd8one")
-    await ctx.db.set_format_thumb(OWNER, two["id"], b"\xff\xd8two")
-    await ctx.db.select_auto_format(OWNER, one["id"])
-    await click(ctx, OWNER, "th:view")  # the Delete button under the thumbnail it sends belongs to "One"
-    (_chat, _file, kw), = ctx.client.files
-    assert data_of(kw["buttons"])[0] == f"th:rm:{one['id']}"
-    _text, rows = await ctx.app.panel(OWNER, "cap")  # the panel names the format it shows, too
-    assert [d for row in rows for _label, d in row][2:4] == [f"th:view:{one['id']}", f"th:del:{one['id']}"]
-
-    await click(ctx, OWNER, f"au:{two['id']}")  # the user switches to "Two" ...
-    cb = await click(ctx, OWNER, f"th:rm:{one['id']}")  # ... and taps Delete on the old message
-    assert cb.deleted and cb.toasts == ["Thumbnail deleted."]
-    assert await ctx.db.get_format_thumb(OWNER, one["id"]) is None
-    assert await ctx.db.get_format_thumb(OWNER, two["id"]) == b"\xff\xd8two"  # the format in use now is untouched
-
-    await ctx.db.set_format_thumb(OWNER, one["id"], b"\xff\xd8one")
-    await click(ctx, OWNER, f"th:view:{one['id']}")  # viewing from an old panel shows that format's thumbnail
-    assert ctx.client.files[-1][1].read() == b"\xff\xd8one"
-    await click(ctx, OWNER, f"th:del:{one['id']}")
-    assert await ctx.db.get_format_thumb(OWNER, one["id"]) is None and await ctx.db.get_format_thumb(OWNER, two["id"]) == b"\xff\xd8two"
-
-
-async def test_a_thumbnail_button_of_a_format_that_is_gone_or_not_theirs_does_nothing(ctx):
-    mine = await ctx.db.create_format(OWNER, "Mine", kind="auto")
-    manual = await ctx.db.create_format(OWNER, "Manual", kind="manual")
-    theirs = await ctx.db.create_format(ADMIN_CFG, "Theirs", kind="auto")
-    for fid in (mine["id"], manual["id"], theirs["id"]):
-        await ctx.db.set_format_thumb(OWNER if fid != theirs["id"] else ADMIN_CFG, fid, b"\xff\xd8keep")
-    await ctx.db.delete_format(OWNER, mine["id"])  # an old message of a format that has since been deleted
-    for fid in (mine["id"], manual["id"], theirs["id"], 999999):
-        for action in ("rm", "del", "view"):
-            cb = await click(ctx, OWNER, f"th:{action}:{fid}")
-            assert cb.alerts == ["That format no longer exists."] and not cb.deleted and cb.edits == []
-    assert await ctx.db.get_format_thumb(OWNER, manual["id"]) == b"\xff\xd8keep"
-    assert await ctx.db.get_format_thumb(ADMIN_CFG, theirs["id"]) == b"\xff\xd8keep" and ctx.client.files == []
-
-
-async def test_the_thumbnail_buttons_leave_manual_formats_alone(ctx):
-    manual = await ctx.db.create_format(OWNER, "Manual", kind="manual")
-    await ctx.db.set_format_thumb(OWNER, manual["id"], b"\xff\xd8mine")
-    await set_auto_thumb(ctx, b"\xff\xd8auto")
-    await click(ctx, OWNER, "th:del")
-    await click(ctx, OWNER, "th:rm")
-    assert await auto_thumb(ctx) is None and await ctx.db.get_format_thumb(OWNER, manual["id"]) == b"\xff\xd8mine"
+async def test_the_buttons_of_the_old_caption_template_and_thumbnail_screens_do_nothing(ctx):
+    auto = await set_auto_thumb(ctx, b"\xff\xd8keep")
+    await edit_auto(ctx, template="{title}", caption="<i>{filename}</i>")
+    before = await autofmt(ctx)
+    old = ["m:cap", "in:template", "in:caption", "clr:caption"] + [f"th:{a}{b}" for a in ("view", "del", "rm") for b in ("", f":{auto['id']}")]
+    for data in old:
+        cb = await click(ctx, OWNER, data)
+        assert cb.edits == [] and cb.alerts == [] and not cb.deleted, data
+    assert not ctx.app.pending and ctx.client.files == []
+    assert await autofmt(ctx) == before and await auto_thumb(ctx) == b"\xff\xd8keep"  # nothing was changed
 
 
 # ---------------------------------------------------------------------------
@@ -747,10 +683,6 @@ async def test_toggles_update_settings_and_refresh_the_panel(ctx):
 
 
 async def test_clear_buttons(ctx):
-    await edit_auto(ctx, caption="custom {filename}")
-    assert (await autofmt(ctx))["caption"] == "custom {filename}"
-    cb = await click(ctx, OWNER, "clr:caption")
-    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>" and "CAPTION" in cb.edits[-1][0]
     await say(ctx, OWNER, "/keepaudio 2 1")
     await say(ctx, OWNER, "/keepsubtitle 1")
     cb = await click(ctx, OWNER, "clr:keep_audio")
@@ -763,7 +695,7 @@ async def test_clear_buttons(ctx):
 
 
 async def test_close_deletes_the_message_and_falls_back_to_editing(ctx):
-    ctx.app.pending[OWNER] = Pending("template", OWNER, 1, "rename", False, time.time() + 100)
+    ctx.app.pending[OWNER] = Pending("remove", OWNER, 1, "rename", False, time.time() + 100)
     cb = await click(ctx, OWNER, "x:close")
     assert cb.deleted and OWNER not in ctx.app.pending
     old = FakeCallback(OWNER, "x:close")
@@ -824,14 +756,14 @@ async def test_every_prompt_opens_and_cancels(ctx, kind):
 # ---------------------------------------------------------------------------
 
 
-async def test_template_prompt_flow(ctx):
-    await click(ctx, OWNER, "in:template", msg_id=500)
-    ev = await say(ctx, OWNER, "{title} [{quality}]", mid=60)
+async def test_remove_words_prompt_flow(ctx):
+    await click(ctx, OWNER, "in:remove", msg_id=500)
+    ev = await say(ctx, OWNER, "@Chan, [Group]", mid=60)
     assert ev.deleted and OWNER not in ctx.app.pending  # the typed value is removed to keep the chat tidy
-    assert (await autofmt(ctx))["template"] == "{title} [{quality}]"
+    assert (await prefs(ctx))["remove_words"] == ["@Chan", "[Group]"]
     (chat, text, kw), = ctx.client.edited
-    assert chat == OWNER and kw["message"] == 500 and "Template saved" in text and "RENAME MODE" in text
-    assert "rename" == "rename" and "set:mode:filename" in data_of(kw["buttons"])
+    assert chat == OWNER and kw["message"] == 500 and "I'll strip" in text and "RENAME MODE" in text
+    assert "set:mode:filename" in data_of(kw["buttons"]) and "in:template" not in data_of(kw["buttons"])
 
 
 async def test_keep_audio_prompt_flow_enables_metadata_and_returns_to_the_tool_panel(ctx):
@@ -844,22 +776,22 @@ async def test_keep_audio_prompt_flow_enables_metadata_and_returns_to_the_tool_p
 
 
 async def test_invalid_input_keeps_the_prompt_open(ctx):
-    await click(ctx, OWNER, "in:template")
+    await click(ctx, OWNER, "in:mt_title")
     ev = await say(ctx, OWNER, "x" * 300)
     assert "too long" in ev.texts[0] and "Try again" in ev.texts[0] and not ev.deleted
     assert OWNER in ctx.app.pending and ctx.client.edited == []
-    ev = await say(ctx, OWNER, "{title}")
-    assert OWNER not in ctx.app.pending and (await autofmt(ctx))["template"] == "{title}"
+    ev = await say(ctx, OWNER, "My Title")
+    assert OWNER not in ctx.app.pending and (await prefs(ctx))["meta"]["title"] == "My Title"
 
 
 async def test_expired_prompts_and_other_users_text_are_ignored(ctx):
-    await click(ctx, OWNER, "in:template")
-    assert (await say(ctx, ADMIN_CFG, "{title}")).out == []  # not their prompt
+    await click(ctx, OWNER, "in:mt_title")
+    assert (await say(ctx, ADMIN_CFG, "Title")).out == []  # not their prompt
     assert OWNER in ctx.app.pending
     ctx.app.pending[OWNER].expires = time.time() - 1
-    ev = await say(ctx, OWNER, "{title}")
+    ev = await say(ctx, OWNER, "Title")
     assert ev.out == [] and not ev.deleted and OWNER not in ctx.app.pending
-    assert await autofmt(ctx) is None  # nothing was saved
+    assert (await prefs(ctx))["meta"]["title"] == "" and (await prefs(ctx, ADMIN_CFG))["meta"]["title"] == ""  # nothing was saved
 
 
 async def test_plain_text_without_a_prompt_is_ignored(ctx):

tests/test_caption_formatting_app.py

@@ -1,11 +1,11 @@
 """A caption keeps the formatting it was sent with (bold, italic, links...): nobody has to type HTML.
 
-The Set Caption button edits the caption of the auto format in use, so ``autofmt`` is where it is read back."""
+The caption of the auto format is edited on that format's screen in /formats (the Caption button), so ``autofmt`` is where it is read back."""
 from telethon.extensions import html as telegram_html
 
 from bot.pipeline import make_caption
 
-from .appkit import OWNER, autofmt, click, data_of, edit_auto, say, say_formatted
+from .appkit import OWNER, autofmt, click, data_of, edit_auto, ensure_auto, say, say_formatted
 from .test_formats_app import make_format
 
 FORMATTED = "[b]Watch[/b] {title} [i]episode {episode}[/i] on [a=https://t.me/Anime_X]our channel[/a]"
@@ -13,36 +13,39 @@ STORED = '<b>Watch</b> {title} <i>episode {episode}</i> on <a href="https://t.me
 
 
 async def set_caption(ctx, markup, *, formatted=True):
-    """Tap Set Caption and send the caption (``markup`` as ``say_formatted`` takes it, or typed as it is with ``formatted=False``).
+    """Tap Caption on the auto format's screen and send the caption (``markup`` as ``say_formatted`` takes it, or typed as it is
+    with ``formatted=False``).
 
     Returns the message sent and the text the prompt's message turned into once the caption was taken (empty when it was refused)."""
+    auto = await ensure_auto(ctx.db)
     edited = len(ctx.client.edited)
-    await click(ctx, OWNER, "in:caption", msg_id=500)
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:caption", msg_id=500)
     ev = await (say_formatted if formatted else say)(ctx, OWNER, markup)
     return ev, (ctx.client.edited[-1][1] if len(ctx.client.edited) > edited else "")
 
 
 # ---------------------------------------------------------------------------
-# the Set Caption button, then the caption
+# the Caption button of the auto format, then the caption
 # ---------------------------------------------------------------------------
 
 
-async def test_the_set_caption_prompt_keeps_the_formatting(ctx):
-    cb = await click(ctx, OWNER, "in:caption", msg_id=500)
+async def test_the_caption_prompt_keeps_the_formatting(ctx):
+    auto = await ensure_auto(ctx.db)
+    cb = await click(ctx, OWNER, f"fm:in:{auto['id']}:caption", msg_id=500)
     assert "No HTML needed" in cb.edits[-1][0]
     ev = await say_formatted(ctx, OWNER, FORMATTED, mid=60)
     assert ev.deleted and OWNER not in ctx.app.pending
     assert (await autofmt(ctx))["caption"] == STORED
     (chat, text, kw), = ctx.client.edited
-    assert kw["message"] == 500 and "Caption template saved" in text and "CAPTION" in text and "Unknown" not in text
-    assert STORED in text and "&lt;b&gt;" not in text  # the panel shows the caption formatted
-    assert "in:caption" in data_of(kw["buttons"])
+    assert kw["message"] == 500 and "Caption template saved" in text and "Unknown" not in text
+    assert STORED in text and "&lt;b&gt;" not in text  # the format's screen shows the caption formatted
+    assert f"fm:in:{auto['id']}:caption" in data_of(kw["buttons"])
 
 
-async def test_the_caption_screen_shows_the_caption_with_its_formatting(ctx):
-    await edit_auto(ctx, caption=STORED)
-    text = (await click(ctx, OWNER, "m:cap")).edits[-1][0]
-    assert "Of the auto format" in text and STORED in text  # shown as the person wrote it, not as tags to read
+async def test_the_format_screen_shows_the_caption_with_its_formatting(ctx):
+    auto = await edit_auto(ctx, caption=STORED)
+    text = (await click(ctx, OWNER, f"fm:v:{auto['id']}")).edits[-1][0]
+    assert STORED in text  # shown as the person wrote it, not as tags to read
     assert "&lt;b&gt;" not in text and "&lt;a href" not in text
 
 
@@ -99,27 +102,30 @@ async def test_unknown_variables_are_still_reported(ctx):
 async def test_a_caption_that_is_too_long_with_its_link_addresses_is_refused(ctx):
     ev, text = await set_caption(ctx, f"[a=https://example.com/{'a' * 800}]link[/a] {{filename}}")
     assert "too long" in ev.texts[0] and "link addresses" in ev.texts[0] and text == ""
-    assert await autofmt(ctx) is None  # nothing was saved, so there is no format either
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>"  # nothing was saved
 
 
-async def test_the_set_caption_prompt_still_takes_typed_html_and_reset(ctx):
-    await click(ctx, OWNER, "in:caption")
+async def test_the_caption_prompt_still_takes_typed_html_and_reset(ctx):
+    auto = await ensure_auto(ctx.db)
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:caption")
     await say(ctx, OWNER, "<u>{filename}</u> {size}")
     assert (await autofmt(ctx))["caption"] == "<u>{filename}</u> {size}"
-    await click(ctx, OWNER, "in:caption")
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:caption")
     await say_formatted(ctx, OWNER, "[b]reset[/b]")
     assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>"
 
 
 async def test_formatting_sent_to_another_prompt_is_not_turned_into_html(ctx):
     """Only captions are rich text: a template or a title is plain text, whatever it was formatted with."""
-    await click(ctx, OWNER, "in:template")
+    auto = await ensure_auto(ctx.db)
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:template")
     await say_formatted(ctx, OWNER, "[b]{title}[/b] [i]{quality}[/i]")
     assert (await autofmt(ctx))["template"] == "{title} {quality}"
 
 
 async def test_a_prompt_that_is_refused_stays_open_for_another_try(ctx):
-    await click(ctx, OWNER, "in:caption")
+    auto = await ensure_auto(ctx.db)
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:caption")
     ev = await say_formatted(ctx, OWNER, f"[a=https://example.com/{'a' * 800}]link[/a]")
     assert "too long" in ev.texts[0] and "Try again" in ev.texts[0] and OWNER in ctx.app.pending
     await say_formatted(ctx, OWNER, "[b]{filename}[/b] ok")
@@ -173,11 +179,11 @@ async def test_a_format_caption_reset_works_in_bold_and_other_fields_stay_plain(
 
 
 async def test_a_link_in_a_caption_gets_no_link_preview_on_any_screen_that_shows_it(ctx):
-    await edit_auto(ctx, caption=STORED)
-    cb = await click(ctx, OWNER, "m:cap")
+    auto = await edit_auto(ctx, caption=STORED)
+    cb = await click(ctx, OWNER, f"fm:v:{auto['id']}")
     assert STORED in cb.edits[-1][0] and cb.edit_kwargs[-1]["link_preview"] is False
 
-    await click(ctx, OWNER, "in:caption", msg_id=500)
+    await click(ctx, OWNER, f"fm:in:{auto['id']}:caption", msg_id=500)
     await say_formatted(ctx, OWNER, FORMATTED)
     assert STORED in ctx.client.edited[-1][1] and ctx.client.edited[-1][2]["link_preview"] is False
 

tests/test_ethumb.py

@@ -161,10 +161,11 @@ async def test_it_handles_one_file_per_command(ctx):
     assert "Queued" in later.texts[0]  # normal auto-rename is back
 
 
-async def test_a_photo_while_waiting_still_sets_the_thumbnail_as_usual(ctx):
+async def test_a_photo_while_waiting_is_ignored_and_the_wait_goes_on(ctx):
     await say(ctx, OWNER, "/ethumb")
-    await dispatch(ctx.client, FakeEvent(OWNER, message=FakeMessage("", photo=True, mid=80), photo_bytes=jpeg()))
-    assert await auto_thumb(ctx) and ctx.app.modes[OWNER].kind == "ethumb"
+    ev = FakeEvent(OWNER, message=FakeMessage("", photo=True, mid=80), photo_bytes=jpeg())
+    await dispatch(ctx.client, ev)
+    assert ev.out == [] and await auto_thumb(ctx) is None and ctx.app.modes[OWNER].kind == "ethumb"  # a photo is nobody's thumbnail
 
 
 async def test_cancel_and_the_stop_button_end_it(ctx):

tests/test_formats.py

@@ -1,12 +1,9 @@
-import asyncio
-
 import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from bot.db import DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_SETTINGS, MAX_FORMATS, Database
 from bot.errors import FormatError
 from bot.formats import (
-    NAME_MAX, AutoFormatSettings, FormatSettings, apply_format, default_auto_format, default_metadata_changes, has_default_metadata,
+    NAME_MAX, FormatSettings, apply_format, default_auto_format, default_metadata_changes, has_default_metadata,
     has_metadata, other_kind, validate_name,
 )
 from bot.parser import DEFAULT_TEMPLATE
@@ -431,55 +428,6 @@ async def test_deleting_the_auto_format_in_use_hands_over_to_another(db):
     assert await db.get_auto_format(U) is None and (await db.get_settings(U))["auto_format"] == 0
 
 
-async def test_ensure_auto_format_makes_a_default_one_only_when_there_is_none(db):
-    await db.create_format(U, "Default")  # a manual one of that name does not count
-    made = await db.ensure_auto_format(U)
-    assert made["name"] == "Default" and made["kind"] == "auto" and made["template"] == DEFAULT_TEMPLATE
-    assert (await db.get_auto_format(U))["id"] == made["id"]
-    assert (await db.ensure_auto_format(U))["id"] == made["id"] and await db.count_formats(U, "auto") == 1
-    other = await db.create_format(U, "Other", kind="auto")
-    await db.select_auto_format(U, other["id"])
-    assert (await db.ensure_auto_format(U))["id"] == other["id"]  # the one in use, never a second default
-
-
-async def test_ensure_auto_format_asked_by_several_tasks_at_once_makes_one_default(db, monkeypatch):
-    original = AsyncSession.execute
-
-    async def slower(self, *args, **kwargs):  # lets the tasks interleave, as photos sent together do
-        result = await original(self, *args, **kwargs)
-        await asyncio.sleep(0.01)
-        return result
-
-    monkeypatch.setattr(AsyncSession, "execute", slower)
-    made = await asyncio.gather(*(db.ensure_auto_format(U) for _ in range(4)))
-    assert len({f["id"] for f in made}) == 1 and await db.count_formats(U, "auto") == 1
-    assert (await db.get_settings(U))["auto_format"] == made[0]["id"]
-    other = await asyncio.gather(db.ensure_auto_format(V), db.ensure_auto_format(V))  # each user has their own
-    assert other[0]["id"] == other[1]["id"] != made[0]["id"] and await db.count_formats(V, "auto") == 1
-
-
-async def test_auto_format_settings_edit_the_one_in_use_and_make_it_when_needed(db):
-    store = AutoFormatSettings(db)
-    shown = await store.get_settings(U)  # looking is not changing: nothing is made
-    assert shown["template"] == DEFAULT_TEMPLATE and shown["caption"] == DEFAULT_CAPTION and await db.count_formats(U) == 0
-
-    ok, msg = await apply_setting(store, U, "template", "[S{season}E{episode}] {title}")
-    assert ok and "Template saved" in msg
-    (auto,) = await db.list_formats(U, "auto")
-    assert auto["name"] == "Default" and auto["template"] == "[S{season}E{episode}] {title}"
-    ok, _ = await apply_setting(store, U, "caption", "<i>{filename}</i>")
-    assert ok and (await db.get_auto_format(U))["caption"] == "<i>{filename}</i>" and await db.count_formats(U) == 1
-    assert (await store.get_settings(U))["template"] == "[S{season}E{episode}] {title}"
-    ok, _ = await apply_setting(store, U, "caption", "reset")
-    assert ok and (await db.get_auto_format(U))["caption"] == DEFAULT_CAPTION
-    assert await db.get_settings(U) == {**DEFAULT_SETTINGS, "auto_format": auto["id"]}  # the user's own settings only remember which one
-
-    second = await db.create_format(U, "Second", kind="auto")  # with several, the one in use is the one that is edited
-    await db.select_auto_format(U, second["id"])
-    await apply_setting(store, U, "template", "{title}")
-    assert (await db.get_format(U, second["id"]))["template"] == "{title}" and (await db.get_format(U, auto["id"]))["template"] != "{title}"
-
-
 # ---------------------------------------------------------------------------
 # a format over the user's settings, and the default metadata
 # ---------------------------------------------------------------------------

tests/test_formats_app.py

@@ -298,14 +298,14 @@ async def test_a_format_thumbnail_is_saved_shown_and_deleted(ctx):
     assert panels.THUMB_NONE in cb.edits[-1][0]
 
 
-async def test_a_photo_without_a_pending_format_prompt_is_the_thumbnail_of_the_auto_format(ctx):
+async def test_a_photo_after_cancelling_the_thumbnail_prompt_is_not_a_thumbnail(ctx):
     manual = await make_format(ctx)
+    await click(ctx, OWNER, f"fm:th:{manual['id']}", msg_id=800)
+    await click(ctx, OWNER, f"fm:cx:{manual['id']}")  # Cancel
+    assert OWNER not in ctx.app.pending
     ev = FakeEvent(OWNER, message=FakeMessage("", mid=900, photo=True), photo_bytes=jpeg())
     await dispatch(ctx.client, ev)
-    assert "Thumbnail saved" in ev.texts[0] and "auto format" in ev.texts[0]
-    auto = await autofmt(ctx)
-    assert auto["name"] == "Default" and await ctx.db.get_format_thumb(OWNER, auto["id"]) is not None
-    assert await ctx.db.get_format_thumb(OWNER, manual["id"]) is None
+    assert ev.out == [] and await ctx.db.get_format_thumb(OWNER, manual["id"]) is None and await autofmt(ctx) is None
 
 
 async def test_deleting_a_format_asks_first(ctx):

tests/test_media.py

@@ -4,6 +4,7 @@ import pytest
 
 from bot.errors import Cancelled, MediaError
 from bot.media import (
+    ImageTooBig,
     MediaInfo,
     Stream,
     apply_plan,
@@ -12,13 +13,13 @@ from bot.media import (
     extract_frame,
     format_tracks,
     frame_seeks,
+    image_size,
     make_video_thumbnail,
     parse_probe,
-    parse_size,
     parse_track_tokens,
     prepare_thumb,
     probe,
-    resize_image,
+    resize_exact,
     resolve_tokens,
     validate_track_tokens,
 )
@@ -326,7 +327,7 @@ async def test_thumbnail_and_prepare_thumb(media_dir, tmp_path):
 
 
 # ---------------------------------------------------------------------------
-# /ethumb and /resize helpers
+# /ethumb, /size and /resize helpers
 # ---------------------------------------------------------------------------
 
 
@@ -338,76 +339,121 @@ def test_frame_seeks_start_at_about_a_tenth_and_fall_back_to_earlier_positions()
     assert frame_seeks(-5) == [1.0, 0.0]
 
 
-@pytest.mark.parametrize("text,expected", [
-    ("320", (320, 320)), (" 320 ", (320, 320)), ("320x180", (320, 180)), ("320X180", (320, 180)), ("320×180", (320, 180)),
-    ("320 x 180", (320, 180)), ("320*180", (320, 180)), ("320 180", (320, 180)), ("320,180", (320, 180)),
-    ("16x16", (16, 16)), ("4096x4096", (4096, 4096)),
-    ("15x300", None), ("5000", None), ("99999x99999", None), ("320x", None), ("x180", None), ("320x180x90", None),
-    ("320 px", None), ("-5", None), ("abc", None), ("", None),
-])
-def test_parse_size(text, expected):
-    assert parse_size(text) == expected
-
-
-def _png(size, color=(10, 120, 200), mode="RGB"):
+def _png(size, color=(10, 120, 200), mode="RGB", exif_orientation=None):
     import io
     from PIL import Image
 
+    img = Image.new(mode, size, color)
+    kw = {}
+    if exif_orientation:
+        exif = img.getexif()
+        exif[274] = exif_orientation
+        kw["exif"] = exif
     buf = io.BytesIO()
-    Image.new(mode, size, color).save(buf, "PNG")
+    img.save(buf, "PNG", **kw)
     return buf.getvalue()
 
 
-def test_resize_image_fits_inside_the_box_and_keeps_the_shape():
+def _opened(data):
     import io
     from PIL import Image
 
-    data, original, new = resize_image(_png((1920, 1080)), 320, 320)
-    assert original == (1920, 1080) and new == (320, 180)
-    img = Image.open(io.BytesIO(data))
-    assert img.format == "JPEG" and img.size == new
-    assert resize_image(_png((1920, 1080)), 100, 400)[2] == (100, 56)
-    assert resize_image(_png((1000, 2000)), 500, 500)[2] == (250, 500)
-    assert resize_image(_png((100, 50)), 400, 400)[2] == (400, 200)  # small images are scaled up to the size asked for
+    return Image.open(io.BytesIO(data))
+
+
+def test_image_size_is_the_width_and_the_height():
+    assert image_size(_png((1920, 1080))) == (1920, 1080)
+    assert image_size(_png((7, 300))) == (7, 300)
+
+
+def test_image_size_counts_a_picture_stored_sideways_as_turned_upright():
+    assert image_size(_png((200, 100), exif_orientation=6)) == (100, 200)
+    assert image_size(_png((200, 100), exif_orientation=8)) == (100, 200)
+    assert image_size(_png((200, 100), exif_orientation=1)) == (200, 100)
+    assert image_size(_png((200, 100), exif_orientation=3)) == (200, 100)  # upside down: the same width and height
+
+
+def test_image_size_rejects_what_is_not_an_image():
+    with pytest.raises(Exception):
+        image_size(b"definitely not an image")
+
+
+@pytest.mark.parametrize("source,wanted", [
+    ((1920, 1080), (720, 1080)), ((100, 50), (400, 400)), ((1000, 2000), (3, 900)), ((640, 480), (1, 1)), ((64, 64), (64, 64)),
+])
+def test_resize_exact_gives_exactly_the_size_asked_for_whatever_the_shape(source, wanted):
+    img = _opened(resize_exact(_png(source), *wanted))
+    assert img.format == "PNG" and img.size == wanted
+
 
+def test_resize_exact_stretches_the_whole_picture():
+    from PIL import Image
 
-def test_a_thumbnail_sized_result_stays_under_200_kb_even_for_noisy_images():
+    two_halves = Image.new("RGB", (200, 100), (0, 0, 255))
+    two_halves.paste((255, 0, 0), (0, 0, 100, 100))
     import io
+
+    buf = io.BytesIO()
+    two_halves.save(buf, "PNG")
+    out = _opened(resize_exact(buf.getvalue(), 40, 400)).convert("RGB")
+    assert out.getpixel((2, 5)) == out.getpixel((2, 395)) == (255, 0, 0)
+    assert out.getpixel((37, 5)) == out.getpixel((37, 395)) == (0, 0, 255)
+
+
+def test_resize_exact_keeps_transparency_and_does_not_turn_it_white_or_black():
+    img = _opened(resize_exact(_png((200, 200), (0, 0, 0, 0), mode="RGBA"), 100, 50))
+    assert img.mode == "RGBA" and img.getpixel((50, 25))[3] == 0
+
+
+def test_resize_exact_turns_a_picture_stored_sideways_upright_first():
     from PIL import Image
+    import io
 
-    noisy = io.BytesIO()
-    Image.effect_noise((2000, 2000), 90).convert("RGB").save(noisy, "PNG")
-    data, _original, new = resize_image(noisy.getvalue(), 320, 320)
-    assert max(new) == 320 and len(data) <= 200 * 1024
-    big, _o, bigsize = resize_image(noisy.getvalue(), 1280, 1280)  # larger results are not squeezed
-    assert max(bigsize) == 1280 and len(big) > 200 * 1024
+    img = Image.new("RGB", (200, 100), (0, 0, 255))
+    img.paste((255, 0, 0), (0, 0, 100, 100))  # the left half is red
+    exif = img.getexif()
+    exif[274] = 6
+    buf = io.BytesIO()
+    img.save(buf, "PNG", exif=exif)
+    out = _opened(resize_exact(buf.getvalue(), 100, 200)).convert("RGB")
+    assert out.getpixel((50, 10)) == (255, 0, 0) and out.getpixel((50, 190)) == (0, 0, 255)  # red on top: it was turned
 
 
-def test_transparent_images_get_a_white_background_not_a_black_one():
+@pytest.mark.parametrize("mode,saved_as", [("P", "PNG"), ("1", "PNG"), ("LA", "PNG"), ("L", "PNG"), ("CMYK", "JPEG"), ("RGBA", "PNG")])
+def test_resize_exact_takes_every_kind_of_picture(mode, saved_as):
     import io
     from PIL import Image
 
-    data, _o, _n = resize_image(_png((200, 200), (0, 0, 0, 0), mode="RGBA"), 100, 100)
-    pixel = Image.open(io.BytesIO(data)).getpixel((50, 50))
-    assert min(pixel) > 240
+    buf = io.BytesIO()
+    Image.new(mode, (30, 20)).save(buf, saved_as)
+    img = _opened(resize_exact(buf.getvalue(), 15, 10))
+    assert img.format == "PNG" and img.size == (15, 10)
 
 
-def test_exif_orientation_is_applied():
+def test_resize_exact_keeps_a_palette_picture_smooth_not_blocky():
     import io
     from PIL import Image
 
-    img = Image.new("RGB", (200, 100), (200, 0, 0))
-    exif = img.getexif()
-    exif[274] = 6  # rotate 90 degrees clockwise when displayed
+    ramp = Image.new("L", (256, 1))
+    ramp.putdata(list(range(256)))
     buf = io.BytesIO()
-    img.save(buf, "JPEG", exif=exif)
-    _data, original, new = resize_image(buf.getvalue(), 100, 100)
-    assert original == (100, 200) and new == (50, 100)
+    ramp.convert("P").save(buf, "PNG")
+    out = _opened(resize_exact(buf.getvalue(), 64, 1)).convert("L")
+    values = [out.getpixel((x, 0)) for x in range(64)]
+    assert len(set(values)) > 50 and values == sorted(values)  # a gradient, not a few flat bands
+
+
+def test_resize_exact_refuses_a_picture_with_too_many_pixels(monkeypatch):
+    monkeypatch.setattr("bot.media.RESIZE_MAX_PIXELS", 400)
+    with pytest.raises(ImageTooBig):
+        resize_exact(_png((21, 20)), 5, 5)
+    assert _opened(resize_exact(_png((20, 20)), 5, 5)).size == (5, 5)  # right at the limit is fine
+    assert issubclass(ImageTooBig, ValueError)
 
 
-def test_resize_image_rejects_what_is_not_an_image():
+def test_resize_exact_rejects_what_is_not_an_image():
     with pytest.raises(Exception):
-        resize_image(b"definitely not an image", 100, 100)
+        resize_exact(b"definitely not an image", 100, 100)
 
 
 @needs_ffmpeg

tests/test_panels.py

@@ -56,7 +56,7 @@ def worst_format(fid=12, kind="auto", **over):
     return fmt
 
 
-def every_panel(s, has_thumb=True, auto=None):
+def every_panel(s, auto=None):
     """Every panel of the bot for these settings; ``auto`` is the auto format in use (``None``: the user has none)."""
     formats = [worst_format(i, "auto", name=f"{i:02d}" + "N" * 28) for i in range(1, 13)]
     manual = [worst_format(i + 20, "manual", name=f"{i:02d}" + "M" * 28) for i in range(1, 13)]
@@ -64,7 +64,6 @@ def every_panel(s, has_thumb=True, auto=None):
         "home_owner": panels.home(s, owner=True, auto=auto),
         "home_user": panels.home(s, owner=False, auto=auto),
         "rename": panels.rename(s, auto),
-        "cap": panels.caption(auto, has_thumb),
         "meta": panels.metadata(s),
         "tool": panels.tool(s),
         "ftype": panels.filetype(s),
@@ -125,10 +124,9 @@ def test_every_panel_html_is_balanced():
 
 
 @pytest.mark.parametrize("name, text, shown", [
-    ("template prompt", panels.PROMPTS["template"], TEMPLATE_LIST),
-    ("caption prompt", panels.PROMPTS["caption"], CAPTION_LIST),
+    ("template prompt", panels.FORMAT_PROMPTS["template"], TEMPLATE_LIST),
+    ("caption prompt", panels.FORMAT_PROMPTS["caption"], CAPTION_LIST),
     ("help panel", panels.help_panel()[0], TEMPLATE_LIST),
-    ("caption panel", panels.caption(None, True)[0], CAPTION_LIST),
 ])
 def test_every_variable_is_its_own_tap_to_copy_block(name, text, shown):
     # Tapping a <code> block in Telegram copies all of it, so "{quality}" must not share a block with the other variables.
@@ -207,8 +205,31 @@ def test_home_shows_admin_button_only_to_the_owner():
     owner = [d for row in panels.home(settings(), owner=True)[1] for _l, d in row]
     user = [d for row in panels.home(settings(), owner=False)[1] for _l, d in row]
     assert "m:admin" in owner and "m:admin" not in user
-    for expected in ("m:rename", "m:cap", "m:meta", "m:ftype", "m:help"):
+    for expected in ("m:auto", "m:rename", "m:meta", "m:ftype", "m:formats", "m:help"):
         assert expected in user
+    assert "m:cap" not in owner + user  # the caption and the thumbnail are edited in /formats, not in the start menu
+
+
+def test_the_start_menu_has_no_way_to_edit_the_template_caption_or_thumbnail():
+    auto = sample_format(kind="auto")
+    for name, (_text, rows) in every_panel(settings(), auto=auto).items():
+        if name.startswith(("format_prompt_", "auto_format", "manual_format", "shared", "copied", "delete", "picker", "ready")):
+            continue  # a format's own screens are where those are edited
+        data = [d for row in rows for _l, d in row]
+        assert not any(d in ("in:template", "in:caption", "clr:caption", "m:cap") or d.startswith("th:") for d in data), name
+        assert not any(label in ("Template", "Set Caption", "Caption & Thumbnail", "View Thumb", "Delete Thumb")
+                       for row in rows for label, _d in row), name
+    rename_text, rename_rows = panels.rename(settings(), auto)
+    assert "Change it in /formats" in rename_text and [d for row in rename_rows for _l, d in row][2:4] == ["in:remove", "m:home"]
+    assert set(panels.PROMPTS) == {"remove", "mt_title", "mt_author", "mt_artist", "mt_audio", "mt_subtitle", "mt_video", "keep_audio", "keep_subtitle"}
+    assert "template" in panels.FORMAT_PROMPTS and "caption" in panels.FORMAT_PROMPTS and "thumb" in panels.FORMAT_PROMPTS  # only here
+
+
+def test_the_help_lists_size_and_resize_and_says_where_a_format_is_edited():
+    text = visible(panels.help_panel()[0])
+    assert "/size and /resize (reply to a picture)" in text
+    assert "/formats" in text and "template, caption, thumbnail and metadata" in text
+    assert "Caption & Thumbnail" not in text and "Send a photo" not in text  # both are gone
 
 
 def test_home_metadata_line_says_what_the_auto_format_in_use_will_do():

tests/test_pipeline.py

@@ -13,6 +13,7 @@ from bot.parser import DEFAULT_TEMPLATE, compute_new_name
 from bot.pipeline import Renamer, decide_send_type, guess_mime, original_name_of, source_ext
 from bot.queue import Job
 
+from .appkit import ensure_auto
 from .conftest import needs_ffmpeg
 
 
@@ -170,7 +171,7 @@ async def test_forced_video_for_non_video_falls_back_to_document(env, tmp_path):
 
 async def make_auto(env, thumb=None, **changes):
     """The user's auto format (made on demand), with these changes and this thumbnail."""
-    fmt = await env.db.ensure_auto_format(42)
+    fmt = await ensure_auto(env.db, 42)
     if changes:
         await env.db.update_format(42, fmt["id"], **changes)
     if thumb:

tests/test_settings_ops.py

@@ -1,7 +1,7 @@
 import pytest
 
 from bot.db import DEFAULT_CAPTION, Database
-from bot.formats import AutoFormatSettings
+from bot.formats import FormatSettings
 from bot.parser import DEFAULT_TEMPLATE
 from bot.settings_ops import META_COMMANDS, META_KINDS, apply_setting, parse_channel, preview_template
 
@@ -25,66 +25,57 @@ async def auto(db):
     return await db.get_auto_format(UID)
 
 
-def store(db):
-    return AutoFormatSettings(db)
+@pytest.fixture
+async def store(db):
+    """Where the template and the caption are saved: an auto format (they live in formats, not in the user's settings)."""
+    fmt = await db.create_format(UID, "Default", kind="auto")
+    return FormatSettings(db, fmt["id"])
 
 
-async def test_template_saved_with_preview(db):
-    ok, msg = await apply_setting(store(db), UID, "template", "[S{season}E{episode}] {title} [{quality}]")
+async def test_template_saved_with_preview(db, store):
+    ok, msg = await apply_setting(store, UID, "template", "[S{season}E{episode}] {title} [{quality}]")
     assert ok and "Template saved" in msg and "Preview" in msg
     assert (await auto(db))["template"] == "[S{season}E{episode}] {title} [{quality}]"
     assert "template" not in await get(db)  # the user's own settings don't hold one
 
 
-async def test_template_validation_and_reset(db):
-    assert (await apply_setting(store(db), UID, "template", "   "))[0] is False
-    ok, msg = await apply_setting(store(db), UID, "template", "x" * 201)
+async def test_template_validation_and_reset(db, store):
+    assert (await apply_setting(store, UID, "template", "   "))[0] is False
+    ok, msg = await apply_setting(store, UID, "template", "x" * 201)
     assert not ok and "too long" in msg
-    assert await auto(db) is None  # nothing was saved, so no auto format was made for it either
-    await apply_setting(store(db), UID, "template", "{title}")
+    assert (await auto(db))["template"] == DEFAULT_TEMPLATE  # nothing was saved
+    await apply_setting(store, UID, "template", "{title}")
     assert (await auto(db))["template"] == "{title}"
-    ok, _ = await apply_setting(store(db), UID, "template", "reset")
+    ok, _ = await apply_setting(store, UID, "template", "reset")
     assert ok and (await auto(db))["template"] == DEFAULT_TEMPLATE
 
 
-async def test_template_unknown_variables_are_reported_but_saved(db):
-    ok, msg = await apply_setting(store(db), UID, "template", "{title} {nope}")
+async def test_template_unknown_variables_are_reported_but_saved(db, store):
+    ok, msg = await apply_setting(store, UID, "template", "{title} {nope}")
     assert ok and "{nope}" in msg and "Unknown variables" in msg
     assert (await auto(db))["template"] == "{title} {nope}"
 
 
-async def test_the_padded_episode_variables_are_known_ones(db):
-    ok, msg = await apply_setting(store(db), UID, "template", "{title} E{1episode} {2episode} {3episode}")
+async def test_the_padded_episode_variables_are_known_ones(db, store):
+    ok, msg = await apply_setting(store, UID, "template", "{title} E{1episode} {2episode} {3episode}")
     assert ok and "Unknown" not in msg
     assert "Tokyo Revengers E05 005 0005" in msg  # the preview shows the padding
-    ok, msg = await apply_setting(store(db), UID, "caption", "Episode {2episode} of {title}")
+    ok, msg = await apply_setting(store, UID, "caption", "Episode {2episode} of {title}")
     assert ok and "Unknown" not in msg
 
 
-async def test_caption_set_validate_reset(db):
-    ok, msg = await apply_setting(store(db), UID, "caption", "<b>{filename}</b> · {size}")
+async def test_caption_set_validate_reset(db, store):
+    ok, msg = await apply_setting(store, UID, "caption", "<b>{filename}</b> · {size}")
     assert ok and (await auto(db))["caption"] == "<b>{filename}</b> · {size}"
     assert "Unknown" not in msg
-    assert (await apply_setting(store(db), UID, "caption", "x" * 801))[0] is False
-    assert (await apply_setting(store(db), UID, "caption", ""))[0] is False
-    ok, msg = await apply_setting(store(db), UID, "caption", "{bogus}")
+    assert (await apply_setting(store, UID, "caption", "x" * 801))[0] is False
+    assert (await apply_setting(store, UID, "caption", ""))[0] is False
+    ok, msg = await apply_setting(store, UID, "caption", "{bogus}")
     assert ok and "{bogus}" in msg
-    ok, _ = await apply_setting(store(db), UID, "caption", "reset")
+    ok, _ = await apply_setting(store, UID, "caption", "reset")
     assert ok and (await auto(db))["caption"] == DEFAULT_CAPTION == "<b>{filename}</b>"
 
 
-async def test_the_first_change_makes_an_auto_format_called_default_and_uses_it(db):
-    assert await auto(db) is None
-    assert (await store(db).get_settings(UID))["template"] == DEFAULT_TEMPLATE  # what is shown before there is a format
-    await apply_setting(store(db), UID, "template", "{title}")
-    (made,) = await db.list_formats(UID, "auto")
-    assert made["name"] == "Default" and made["kind"] == "auto" and made["template"] == "{title}"
-    assert (await get(db))["auto_format"] == made["id"] and await auto(db) == made
-    await apply_setting(store(db), UID, "caption", "<i>{filename}</i>")  # the same format, not a second one
-    assert [f["id"] for f in await db.list_formats(UID, "auto")] == [made["id"]]
-    assert (await auto(db))["template"] == "{title}" and (await auto(db))["caption"] == "<i>{filename}</i>"
-
-
 async def test_remove_words(db):
     ok, msg = await apply_setting(db, UID, "remove", "@Chan, [Group]\n www.site.com ,, ")
     assert ok

tests/test_size_resize.py

@@ -0,0 +1,388 @@
+"""/size and /resize: reply to a picture; the first tells its dimensions, the second sends it back at exactly the size given."""
+import asyncio
+import io
+
+import pytest
+from PIL import Image
+
+from bot import app as appmod
+from bot import media
+
+from .appkit import OWNER, STRANGER, click, jpeg, say
+from .tgfakes import FakeEvent, FakeMessage, dispatch, document_message, make_file
+
+FULL_HD = (1920, 1080)
+PROCESSING = "⏳ Processing…"
+HINT = "Give Some Size To Resize, Like <code>/resize 720 1080</code>"
+
+
+def png(size=FULL_HD, mode="RGB", color=(10, 120, 200)):
+    buf = io.BytesIO()
+    Image.new(mode, size, color).save(buf, "PNG")
+    return buf.getvalue()
+
+
+def photo(ctx, mid=50, data=None):
+    """A photo that somebody sent: Telegram gives it whole."""
+    ctx.client.media[mid] = data if data is not None else jpeg(FULL_HD)
+    return FakeMessage("", photo=True, mid=mid)
+
+
+def video(ctx, mid=60, thumb=None):
+    """A video: all that can be read from it is its preview."""
+    ctx.client.thumb_data[mid] = thumb if thumb is not None else jpeg((320, 180))
+    return document_message("Movie.mkv", 90 * 1024 * 1024, mid=mid, video=True)
+
+
+def image_file(ctx, mid=61, data=None, size=300 * 1024, name="poster.png", mime="image/png"):
+    """A picture sent as a file: the file is the picture, its preview is only a small copy."""
+    ctx.client.media[mid] = data if data is not None else png(FULL_HD)
+    ctx.client.thumb_data[mid] = jpeg((320, 180))
+    return document_message(name, size, mid=mid, video=False, mime=mime)
+
+
+def sent_files(ev):
+    return [kw for _text, _buttons, kw in ev.out if kw.get("file") is not None]
+
+
+def result_image(ev):
+    (kw,) = sent_files(ev)
+    return Image.open(io.BytesIO(kw["file"].getvalue()))
+
+
+async def settle(ctx):
+    """Let the background tasks (the hint that removes itself) finish."""
+    await asyncio.gather(*list(ctx.app._tasks))
+
+
+@pytest.fixture
+def quick_hint(monkeypatch):
+    monkeypatch.setattr(appmod, "HINT_SECONDS", 0)
+
+
+# ---------------------------------------------------------------------------
+# the commands
+# ---------------------------------------------------------------------------
+
+
+def test_both_commands_are_in_the_menu_and_the_old_resize_wording_is_gone():
+    menu = dict(appmod.COMMANDS)
+    assert "size" in menu and "resize" in menu
+    assert "reply" in menu["size"].lower() and "reply" in menu["resize"].lower() and "thumbnails" not in menu["resize"]
+
+
+async def test_commands_are_for_allowed_users_only(ctx):
+    msg = photo(ctx)
+    ev = await say(ctx, STRANGER, "/size", reply=msg)
+    assert ev.out == []
+    ev = await say(ctx, STRANGER, "/resize 10 10", reply=msg)
+    assert ev.out == [] and ctx.client.downloads == []
+
+
+async def test_the_commands_work_with_the_bot_name_added(ctx):
+    ev = await say(ctx, OWNER, "/size@RenameBot", reply=photo(ctx))
+    assert ctx.client.edited[-1][1].endswith("<code>1920 x 1080</code>")
+    ev = await say(ctx, OWNER, "/resize@RenameBot 64 48", reply=photo(ctx, mid=51))
+    assert result_image(ev).size == (64, 48)
+
+
+# ---------------------------------------------------------------------------
+# /size
+# ---------------------------------------------------------------------------
+
+
+async def test_size_of_a_photo_is_the_size_of_the_whole_photo(ctx):
+    ev = await say(ctx, OWNER, "/size", reply=photo(ctx))
+    assert ev.texts == [PROCESSING]  # one message, which is then edited into the answer
+    status, text, kw = ctx.client.edited[-1]
+    assert status.id == 1001 and kw["parse_mode"] == "html"
+    assert text == "Dimension Of This Image Is\n<code>1920 x 1080</code>"
+    assert ctx.client.downloads == [(50, bytes, None)] and ctx.client.deleted == []
+
+
+async def test_size_of_a_video_gif_or_sticker_with_no_picture_inside_is_the_size_of_its_preview(ctx):
+    await say(ctx, OWNER, "/size", reply=video(ctx))
+    assert ctx.client.edited[-1][1] == "Dimension Of This Image Is\n<code>320 x 180</code>"
+    assert ctx.client.downloads == [(60, bytes, -1)]  # the largest preview Telegram keeps with it
+
+    ctx.client.thumb_data[63] = jpeg((256, 144))
+    gif = FakeMessage("", file=make_file("a.mp4", 100_000, "video/mp4"), gif=True, mid=63)
+    await say(ctx, OWNER, "/size", reply=gif)
+    assert ctx.client.edited[-1][1].endswith("<code>256 x 144</code>") and ctx.client.downloads[-1] == (63, bytes, -1)
+
+
+async def test_size_of_a_picture_sent_as_a_file_is_the_size_of_the_picture_not_of_its_preview(ctx):
+    await say(ctx, OWNER, "/size", reply=image_file(ctx))
+    assert ctx.client.edited[-1][1].endswith("<code>1920 x 1080</code>")  # not the 320 x 180 preview
+    assert ctx.client.downloads == [(61, bytes, None)]
+
+
+async def test_size_of_a_still_sticker_is_read_from_the_sticker(ctx):
+    ctx.client.media[62] = png((512, 460), "RGBA")
+    sticker = FakeMessage("", file=make_file("sticker.webp", 30_000, "image/webp"), sticker=True, mid=62)
+    await say(ctx, OWNER, "/size", reply=sticker)
+    assert ctx.client.edited[-1][1].endswith("<code>512 x 460</code>")
+
+
+async def test_size_counts_a_picture_that_is_stored_sideways_as_turned(ctx):
+    img = Image.new("RGB", (200, 100), (200, 0, 0))
+    exif = img.getexif()
+    exif[274] = 6  # shown turned a quarter
+    buf = io.BytesIO()
+    img.save(buf, "PNG", exif=exif)
+    await say(ctx, OWNER, "/size", reply=image_file(ctx, data=buf.getvalue()))
+    assert ctx.client.edited[-1][1].endswith("<code>100 x 200</code>")
+
+
+async def test_size_without_media_asks_for_it(ctx):
+    ev = await say(ctx, OWNER, "/size")
+    assert ev.texts == ["Reply to a picture or other media with /size to get its dimensions."]
+    plain_text = FakeMessage("just words", mid=70)
+    ev = await say(ctx, OWNER, "/size", reply=plain_text)
+    assert len(ev.out) == 1 and "Reply to a picture" in ev.texts[0]
+    assert ctx.client.downloads == [] and ctx.client.edited == []
+
+
+async def test_size_says_so_when_there_is_no_picture_to_read(ctx):
+    audio = document_message("Song.mp3", 4 * 1024 * 1024, mid=71, video=False, mime="audio/mpeg")  # no preview at all
+    await say(ctx, OWNER, "/size", reply=audio)
+    assert ctx.client.edited[-1][1] == "❌ I couldn't get a picture from that."
+
+    location = FakeMessage("", mid=72)
+    location.media = object()  # a map, a contact, a poll ...: media, but nothing that is a picture
+    await say(ctx, OWNER, "/size", reply=location)
+    assert ctx.client.edited[-1][1] == "❌ There's no picture in that." and len(ctx.client.downloads) == 1
+
+
+async def test_size_says_so_when_the_picture_cannot_be_read(ctx):
+    await say(ctx, OWNER, "/size", reply=photo(ctx, data=b"definitely not an image"))
+    assert ctx.client.edited[-1][1] == "❌ I couldn't read that image."
+
+
+async def test_size_will_not_download_a_huge_picture(ctx):
+    big = image_file(ctx, size=2 * appmod.RESIZE_MAX_BYTES)
+    await say(ctx, OWNER, "/size", reply=big)
+    assert ctx.client.edited[-1][1] == "❌ That picture is 40.00 MB; I can read pictures up to 20.00 MB." and ctx.client.downloads == []
+    ctx.client.edited.clear()
+    await say(ctx, OWNER, "/size", reply=image_file(ctx, mid=62, size=appmod.RESIZE_MAX_BYTES))  # right at the limit is read
+    assert ctx.client.edited[-1][1].endswith("<code>1920 x 1080</code>")
+
+
+# ---------------------------------------------------------------------------
+# /resize: asking for it right
+# ---------------------------------------------------------------------------
+
+
+async def test_resize_without_media_asks_for_it_before_anything_else(ctx):
+    ev = await say(ctx, OWNER, "/resize")
+    assert ev.texts == ["Reply to a picture or other media with /resize and a size, like <code>/resize 720 1080</code>."]
+    ev = await say(ctx, OWNER, "/resize 720 1080")
+    assert "Reply to a picture" in ev.texts[0] and len(ev.out) == 1
+    ev = await say(ctx, OWNER, "/resize 720 1080", reply=FakeMessage("words", mid=70))
+    assert "Reply to a picture" in ev.texts[0] and len(ev.out) == 1
+    assert ctx.client.downloads == [] and ctx.app._tasks == set() and not ctx.app.modes  # and nothing is waiting for a picture
+
+
+async def test_resize_without_a_size_gives_the_hint_and_removes_it_after_a_few_seconds(ctx, quick_hint):
+    ev = await say(ctx, OWNER, "/resize", reply=photo(ctx))
+    assert ev.texts == [HINT] and ev.out[0][1] is None  # no size menu, no buttons: just the hint
+    await settle(ctx)
+    assert ctx.client.deleted == [(OWNER, [1001])]  # the hint, and only the hint, is removed
+    assert ctx.client.downloads == []  # nothing was downloaded for it
+
+
+async def test_the_hint_stays_for_five_seconds(ctx):
+    assert appmod.HINT_SECONDS == 5
+    ev = await say(ctx, OWNER, "/resize", reply=photo(ctx))
+    assert ev.texts == [HINT] and ctx.client.deleted == []  # it is still there
+    (waiting,) = ctx.app._tasks  # a task is waiting to remove it
+    assert not waiting.done()
+    waiting.cancel()
+    await asyncio.gather(waiting, return_exceptions=True)
+    assert ctx.client.deleted == []
+
+
+@pytest.mark.parametrize("args", [
+    "720", "720 1080 1", "a b", "720 b", "720x1080", "720,1080", "-5 10", "7.5 10", "720 1080 px", "٧٢٠ ١٠٨٠", "1_0 2_0",
+])
+async def test_resize_wants_exactly_two_numbers_separated_by_a_space(ctx, quick_hint, args):
+    ev = await say(ctx, OWNER, f"/resize {args}", reply=photo(ctx))
+    assert ev.texts == [HINT], args
+    await settle(ctx)
+    assert ctx.client.downloads == [] and sent_files(ev) == []
+
+
+@pytest.mark.parametrize("args", ["0 100", "100 0", "4097 100", "100 4097", "99999 99999", "000 5"])
+async def test_resize_keeps_to_what_it_can_make(ctx, args):
+    ev = await say(ctx, OWNER, f"/resize {args}", reply=photo(ctx))
+    assert ev.texts == [f"❌ Each side can be 1 to {appmod.RESIZE_MAX_SIDE} pixels, like <code>/resize 720 1080</code>."]
+    assert ctx.client.downloads == [] and ctx.app._tasks == set()  # this one is an answer to read, it stays
+
+
+# ---------------------------------------------------------------------------
+# /resize: the result
+# ---------------------------------------------------------------------------
+
+
+async def test_resize_sends_the_picture_back_at_exactly_that_size_and_removes_the_status(ctx):
+    ev = await say(ctx, OWNER, "/resize 720 1080", reply=photo(ctx))
+    assert ev.texts[0] == PROCESSING and len(ev.out) == 2
+    (kw,) = sent_files(ev)
+    img = result_image(ev)
+    assert img.format == "PNG" and img.size == (720, 1080)  # the shape of the picture is not kept
+    assert kw["file"].name == "resized.png" and kw["force_document"] is False
+    assert ctx.client.deleted == [(OWNER, [1001])]  # the "Processing" message is gone; the result stays
+    assert ctx.client.edited == [] and ctx.client.files == []  # it was a reply to the command, not a separate send
+    assert ctx.client.downloads == [(50, bytes, None)]
+
+
+@pytest.mark.parametrize("wanted", [(100, 100), (3, 900), (1, 1), (1920, 1080), (4096, 1), (1, 4096)])
+async def test_resize_makes_exactly_the_size_asked_for_whatever_the_picture_looked_like(ctx, wanted):
+    ev = await say(ctx, OWNER, "/resize {} {}".format(*wanted), reply=photo(ctx, data=png((640, 480))))
+    assert result_image(ev).size == wanted
+
+
+async def test_extra_spaces_between_the_numbers_do_not_matter(ctx):
+    ev = await say(ctx, OWNER, "/resize   64    48  ", reply=photo(ctx))
+    assert result_image(ev).size == (64, 48)
+
+
+async def test_resize_stretches_the_picture_it_does_not_crop_or_pad_it(ctx):
+    left_red_right_blue = Image.new("RGB", (200, 100), (0, 0, 255))
+    left_red_right_blue.paste((255, 0, 0), (0, 0, 100, 100))
+    buf = io.BytesIO()
+    left_red_right_blue.save(buf, "PNG")
+    ev = await say(ctx, OWNER, "/resize 40 400", reply=photo(ctx, data=buf.getvalue()))
+    img = result_image(ev).convert("RGB")
+    assert img.getpixel((2, 5)) == (255, 0, 0) and img.getpixel((37, 5)) == (0, 0, 255)
+    assert img.getpixel((2, 395)) == (255, 0, 0) and img.getpixel((37, 395)) == (0, 0, 255)  # still the whole picture, top to bottom
+
+
+async def test_a_picture_sent_as_a_file_is_resized_whole_not_its_preview(ctx):
+    ev = await say(ctx, OWNER, "/resize 960 540", reply=image_file(ctx))
+    assert result_image(ev).size == (960, 540) and ctx.client.downloads == [(61, bytes, None)]
+
+
+async def test_a_video_gives_its_preview_resized(ctx):
+    ev = await say(ctx, OWNER, "/resize 640 360", reply=video(ctx))
+    assert result_image(ev).size == (640, 360) and ctx.client.downloads == [(60, bytes, -1)]
+
+
+async def test_transparency_is_kept(ctx):
+    ev = await say(ctx, OWNER, "/resize 50 20", reply=image_file(ctx, data=png((200, 200), "RGBA", (0, 0, 0, 0))))
+    img = result_image(ev)
+    assert img.mode == "RGBA" and img.getpixel((10, 10))[3] == 0
+
+
+async def test_resize_turns_a_picture_stored_sideways_upright_first(ctx):
+    img = Image.new("RGB", (200, 100), (0, 0, 255))
+    img.paste((255, 0, 0), (0, 0, 100, 100))  # the left half is red
+    exif = img.getexif()
+    exif[274] = 6  # shown turned a quarter: the red half ends up on top
+    buf = io.BytesIO()
+    img.save(buf, "PNG", exif=exif)
+    ev = await say(ctx, OWNER, "/resize 100 200", reply=image_file(ctx, data=buf.getvalue()))
+    out = result_image(ev).convert("RGB")
+    assert out.size == (100, 200)
+    assert out.getpixel((50, 10)) != out.getpixel((50, 190))  # top and bottom differ (left and right would not)
+    assert out.getpixel((10, 100)) == out.getpixel((90, 100))
+
+
+@pytest.mark.parametrize("mode,saved_as", [("P", "PNG"), ("1", "PNG"), ("LA", "PNG"), ("L", "PNG"), ("CMYK", "JPEG")])
+async def test_every_kind_of_picture_is_taken(ctx, mode, saved_as):
+    buf = io.BytesIO()
+    Image.new(mode, (30, 20)).save(buf, saved_as)
+    ev = await say(ctx, OWNER, "/resize 15 10", reply=image_file(ctx, data=buf.getvalue()))
+    assert result_image(ev).size == (15, 10), mode
+
+
+# ---------------------------------------------------------------------------
+# /resize: as a photo or as a file
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("size,as_file", [
+    ((720, 1080), False), ((1280, 1280), False), ((1281, 100), True), ((100, 1500), True), ((4096, 4096), True),
+    ((1000, 50), False), ((1000, 49), True), ((1000, 40), True), ((30, 1000), True), ((1, 1), False),
+])
+async def test_it_comes_as_a_photo_unless_telegram_would_change_it(ctx, size, as_file):
+    assert appmod.fits_as_photo(*size, 1000) is (not as_file)
+    if max(size) > 1500 or min(size) < 4:  # the rule is checked for all of them; the real thing for the cheap ones
+        return
+    ev = await say(ctx, OWNER, "/resize {} {}".format(*size), reply=photo(ctx, data=png((64, 48))))
+    assert sent_files(ev)[0]["force_document"] is as_file
+
+
+async def test_a_result_too_big_for_a_photo_comes_as_a_file(ctx, monkeypatch):
+    monkeypatch.setattr(appmod, "PHOTO_MAX_BYTES", 50)  # any PNG is bigger than that
+    ev = await say(ctx, OWNER, "/resize 60 40", reply=photo(ctx))
+    assert sent_files(ev)[0]["force_document"] is True
+
+
+def test_the_photo_rule():
+    assert appmod.fits_as_photo(1280, 1280, 10) and appmod.fits_as_photo(1280, 64, 10)  # 20 times as long as high is the most
+    assert not appmod.fits_as_photo(1280, 63, 10) and not appmod.fits_as_photo(63, 1280, 10)
+    assert not appmod.fits_as_photo(1281, 1281, 10) and not appmod.fits_as_photo(100, 100, 10 * 1024 * 1024 + 1)
+    assert appmod.fits_as_photo(100, 100, 10 * 1024 * 1024)
+
+
+# ---------------------------------------------------------------------------
+# /resize: when it can't
+# ---------------------------------------------------------------------------
+
+
+async def test_resize_says_so_when_there_is_no_picture_to_read(ctx):
+    audio = document_message("Song.mp3", 4 * 1024 * 1024, mid=71, video=False, mime="audio/mpeg")
+    ev = await say(ctx, OWNER, "/resize 10 10", reply=audio)
+    assert ctx.client.edited[-1][1] == "❌ I couldn't get a picture from that." and sent_files(ev) == []
+    assert ctx.client.deleted == []  # the message that says so stays
+
+
+async def test_resize_says_so_when_the_picture_cannot_be_read(ctx):
+    ev = await say(ctx, OWNER, "/resize 10 10", reply=photo(ctx, data=b"definitely not an image"))
+    assert ctx.client.edited[-1][1] == "❌ I couldn't read that image." and sent_files(ev) == []
+
+
+async def test_resize_will_not_download_a_huge_picture(ctx):
+    ev = await say(ctx, OWNER, "/resize 10 10", reply=image_file(ctx, size=2 * appmod.RESIZE_MAX_BYTES))
+    assert "40.00 MB" in ctx.client.edited[-1][1] and ctx.client.downloads == [] and sent_files(ev) == []
+
+
+async def test_resize_will_not_decode_a_picture_with_too_many_pixels(ctx, monkeypatch):
+    monkeypatch.setattr(media, "RESIZE_MAX_PIXELS", 100 * 100)
+    ev = await say(ctx, OWNER, "/resize 10 10", reply=photo(ctx, data=png((101, 100))))
+    assert ctx.client.edited[-1][1] == "❌ That picture has too many pixels for me to resize." and sent_files(ev) == []
+    ev = await say(ctx, OWNER, "/resize 10 10", reply=photo(ctx, mid=51, data=png((100, 100))))
+    assert result_image(ev).size == (10, 10)  # right at the limit is fine
+
+
+async def test_resize_says_so_when_telegram_refuses_the_result(ctx):
+    class Refusing(FakeEvent):
+        async def reply(self, text=None, **kw):
+            if kw.get("file") is not None:
+                raise RuntimeError("PHOTO_INVALID_DIMENSIONS")
+            return await self.respond(text, **kw)
+
+    ev = Refusing(OWNER, "/resize 10 10", reply=photo(ctx))
+    await dispatch(ctx.client, ev)
+    assert ctx.client.edited[-1][1] == "❌ Telegram wouldn't take the resized picture." and ctx.client.deleted == []
+
+
+# ---------------------------------------------------------------------------
+# what /resize used to be is gone
+# ---------------------------------------------------------------------------
+
+
+async def test_the_old_resize_buttons_do_nothing(ctx):
+    for data in ("rz:s:320", "rz:custom", "rz:menu", "rz:stop"):
+        cb = await click(ctx, OWNER, data)
+        assert cb.edits == [] and cb.alerts == [], data
+    assert not ctx.app.modes and not ctx.app.pending
+
+
+async def test_a_picture_sent_after_the_command_is_not_resized_and_nothing_waits_for_one(ctx):
+    ev = await say(ctx, OWNER, "/resize 320 200")
+    assert "Reply to a picture" in ev.texts[0] and not ctx.app.modes and not ctx.app.pending
+    ev = FakeEvent(OWNER, message=photo(ctx, mid=80), photo_bytes=jpeg())
+    await dispatch(ctx.client, ev)
+    assert ev.out == [] and ctx.client.files == []

tests/test_smedia.py

@@ -237,8 +237,8 @@ async def test_extra_files_right_after_are_skipped_and_do_not_become_the_thumbna
     assert (await send_gif(ctx)).out == [] and (await send_image_file(ctx, mid=53)).out == []
     assert len(uploads(ctx)) == 1 and await autofmt(ctx) is None and ctx.app.queue.waiting == 0  # no photo was saved as a thumbnail
     ctx.app._recent[OWNER][1] -= appmod.ONE_SHOT_GRACE + 1
-    await send_photo(ctx, mid=54)
-    assert await auto_thumb(ctx)  # after the grace a photo is the thumbnail of the auto format again
+    ev = await send_photo(ctx, mid=54)
+    assert ev.out == [] and await auto_thumb(ctx) is None and await autofmt(ctx) is None  # after the grace a photo is just ignored
 
 
 # ---------------------------------------------------------------------------

tests/test_stream_rename.py

@@ -17,6 +17,7 @@ from bot.pipeline import Renamer, embedded_thumb, make_caption, source_attribute
 from bot.queue import Job
 from bot.utils import human_duration, human_size
 
+from .appkit import ensure_auto
 from .conftest import needs_ffmpeg
 
 MIB = 1024 * 1024
@@ -144,7 +145,7 @@ def attributes_by_type(kwargs):
 
 async def auto(env, thumb=None, **changes):
     """The user's auto format (made on demand) with these changes and this thumbnail: what renames the files they just send."""
-    fmt = await env.db.ensure_auto_format(42)
+    fmt = await ensure_auto(env.db, 42)
     if changes:
         await env.db.update_format(42, fmt["id"], **changes)
     if thumb: