Automated sync from GitHub

.gitattributes

@@ -1,4 +1,3 @@
-*.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
@@ -6,3 +5,4 @@
 *.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

bot/app.py

@@ -14,7 +14,7 @@ import time
 from dataclasses import dataclass
 from datetime import timezone
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple
 
 import telethon
 from telethon import errors, events, functions, types
@@ -25,7 +25,18 @@ from . import errorlog, media, mediainfo, panels, richtext, speed, sysinfo
 from .config import Config
 from .db import MAX_FORMATS, Database
 from .errors import FormatError
-from .formats import FIELD_KINDS, NAME_MAX, FormatSettings, validate_name
+from .formats import (
+    FIELD_KINDS,
+    KIND_LABELS,
+    NAME_MAX,
+    AutoFormatSettings,
+    FormatSettings,
+    default_auto_format,
+    default_metadata_changes,
+    has_default_metadata,
+    other_kind,
+    validate_name,
+)
 from .parser import compute_new_name, missing_variables, parse_caption, parse_info, split_ext
 from .pipeline import PROBE_EXTS, Renamer, embedded_thumb, original_name_of, source_ext
 from .queue import Job, JobQueue
@@ -39,13 +50,13 @@ log = logging.getLogger(__name__)
 COMMANDS = [
     ("start", "Open the main menu"),
     ("help", "How to use the bot"),
-    ("rename", "Rename files with a saved format"),
-    ("formats", "Create and edit your saved formats"),
+    ("rename", "Rename one file with a manual format"),
+    ("formats", "Auto and manual rename formats"),
     ("sequence", "Collect files to sort by episode"),
     ("sort", "Sort the collected files by episode"),
     ("mode", "Choose Filename or Caption mode"),
-    ("template", "Set the filename template"),
-    ("caption", "Set the caption template"),
+    ("template", "Set the template of your auto format"),
+    ("caption", "Set the caption of your auto format"),
     ("filetype", "Choose how files are sent"),
     ("metadata", "Metadata and track settings"),
     ("keepaudio", "Keep audio tracks by language or number"),
@@ -55,8 +66,8 @@ COMMANDS = [
     ("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"),
-    ("thumb", "View your thumbnail"),
-    ("delthumb", "Delete your thumbnail"),
+    ("thumb", "View the thumbnail of your auto format"),
+    ("delthumb", "Delete the thumbnail of your auto format"),
     ("queue", "Show your queued files"),
     ("cancel", "Cancel your current job"),
     ("speed", "Test the bot's internet speed (Ookla)"),
@@ -70,7 +81,7 @@ BACK = {
     "mt_audio": "meta", "mt_subtitle": "meta", "mt_video": "meta",
     "keep_audio": "tool", "keep_subtitle": "tool",
 }
-PANEL_NAMES = {"home", "rename", "cap", "meta", "tool", "ftype", "help", "admin", "formats"}
+PANEL_NAMES = {"home", "rename", "cap", "meta", "tool", "ftype", "help", "admin", "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
@@ -107,6 +118,7 @@ class Pending:
     is_photo: bool
     expires: float
     fid: int = 0  # the saved format a "fmt:*" prompt is about (0 = one that is being created)
+    fmt_kind: str = ""  # the kind (auto | manual) of the format that is being created
 
 
 @dataclass
@@ -334,7 +346,7 @@ class App:
 
     def _command_table(self) -> Dict[str, Callable[[Any], Awaitable[None]]]:
         table: Dict[str, Callable[[Any], Awaitable[None]]] = {
-            "start": self.cmd_start, "help": self.cmd_help, "rename": self.cmd_rename, "formats": self.cmd_formats,
+            "start": self.cmd_start, "help": self.cmd_help, "rename": self.cmd_rename, "formats": self.cmd_formats, "format": self.cmd_formats,
             "sequence": self.cmd_sequence, "sort": self.cmd_sort, "mode": self.cmd_mode,
             "template": self.cmd_template, "caption": self.cmd_caption, "filetype": self.cmd_filetype,
             "metadata": self.cmd_metadata, "keepaudio": self._cmd_keep("keep_audio", "Keep Audio", "/keepaudio English Japanese"),
@@ -380,11 +392,12 @@ class App:
     async def panel(self, uid: int, name: str) -> panels.Panel:
         s = await self.db.get_settings(uid)
         if name == "home":
-            return panels.home(s, owner=self.is_owner(uid))
+            return panels.home(s, owner=self.is_owner(uid), auto=await self.db.get_auto_format(uid))
         if name == "rename":
-            return panels.rename(s)
+            return panels.rename(s, await self.db.get_auto_format(uid))
         if name == "cap":
-            return panels.caption(s, await self.db.has_thumb(uid))
+            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":
@@ -394,7 +407,12 @@ class App:
         if name == "help":
             return panels.help_panel()
         if name == "formats":
-            return panels.formats_menu(await self.db.list_formats(uid), MAX_FORMATS)
+            return panels.formats_home(
+                await self.db.count_formats(uid, "auto"), await self.db.count_formats(uid, "manual"), MAX_FORMATS
+            )
+        if name == "auto":
+            active = await self.db.get_auto_format(uid)
+            return panels.auto_menu(await self.db.list_formats(uid, "auto"), active["id"] if active else 0, MAX_FORMATS)
         if name == "admin":
             return panels.admin(
                 self.cfg.owner_id, sorted(self.admins), self.queue.running, self.queue.waiting, self.cfg.log_channel
@@ -529,33 +547,45 @@ 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_template(self, event: Any) -> None:
         arg = self._args(event)
         uid = event.sender_id
         if arg:
-            _ok, msg = await apply_setting(self.db, uid, "template", arg)
+            _ok, msg = await apply_setting(self._store("template"), uid, "template", arg)
             await self._reply(event, msg)
             return
-        s = await self.db.get_settings(uid)
+        auto = await self.db.get_auto_format(uid) or default_auto_format()
         await self._reply(
             event,
-            f"<b>Current template:</b>\n<code>{esc(s['template'])}</code>\n\n{preview_template(s['template'])}\n\n"
+            f"<b>Template of your auto format{self._named(auto)}:</b>\n<code>{esc(auto['template'])}</code>\n\n"
+            f"{preview_template(auto['template'])}\n\n"
             f"Variables: {panels.TEMPLATE_VARIABLES}\n"
+            f"{panels.EPISODE_ZEROS}\n"
             "A [bracket] group is dropped when a variable inside it is empty.\n\n"
             "Change it: <code>/template [S{season}E{episode}] {title} [{quality}]</code>",
         )
 
+    @staticmethod
+    def _named(auto: Dict[str, Any]) -> str:
+        """`` “One Piece”`` for a saved auto format, nothing for the built-in default."""
+        return f" “{esc(clip(auto['name'], 30))}”" if auto.get("name") else ""
+
     async def cmd_caption(self, event: Any) -> None:
         arg = self._args(event)
         uid = event.sender_id
         if arg:
-            _ok, msg = await apply_setting(self.db, uid, "caption", self._caption_input(event, event.pattern_match.start(1)))
+            value = self._caption_input(event, event.pattern_match.start(1))
+            _ok, msg = await apply_setting(self._store("caption"), uid, "caption", value)
             await self._reply(event, msg)
             return
-        s = await self.db.get_settings(uid)
+        auto = await self.db.get_auto_format(uid) or default_auto_format()
         await self._reply(
             event,
-            f"<b>Current caption template:</b>\n{richtext.preview(s['caption'], 600)}\n\n"
+            f"<b>Caption of your auto format{self._named(auto)}:</b>\n{richtext.preview(auto['caption'], 600)}\n\n"
             f"Variables: {panels.CAPTION_VARIABLES}\n"
             "Change it: send <code>/caption</code> and your caption in one message. Format it the way you do in any message "
             "(<b>bold</b>, <i>italic</i>, links…) and I'll keep it exactly like that.\n"
@@ -629,26 +659,49 @@ 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 command or 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; a command, and the buttons of messages from before that, 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 cmd_thumb(self, event: Any) -> None:
-        data = await self.db.get_thumb(event.sender_id)
+        auto, data = await self._auto_thumb(event.sender_id)
         if not data:
-            await self._reply(event, "You have no thumbnail. Send me a photo to set one.")
+            await self._reply(event, "Your auto format has no thumbnail. Send me a photo to set one.")
             return
-        await self._send_thumb(event.chat_id, data)
+        await self._send_thumb(event.chat_id, data, auto["id"])
 
-    async def _send_thumb(self, chat_id: int, data: bytes) -> 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="Your thumbnail", buttons=panels.to_buttons([[("🗑 Delete", "th:rm"), ("✖ Close", "x:close")]])
+            chat_id, bio, caption="Thumbnail of your auto format",
+            buttons=panels.to_buttons([[("🗑 Delete", f"th:rm:{fid}"), ("✖ Close", "x:close")]]),
         )
 
     async def cmd_delthumb(self, event: Any) -> None:
-        if await self.db.has_thumb(event.sender_id):
-            await self.db.set_thumb(event.sender_id, None)
+        if await self._delete_auto_thumb(event.sender_id):
             await self._reply(event, "🗑 Thumbnail deleted.")
         else:
-            await self._reply(event, "You have no thumbnail.")
+            await self._reply(event, "Your auto format has no thumbnail.")
 
     async def on_photo(self, event: Any) -> None:
         uid = event.sender_id
@@ -673,8 +726,12 @@ class App:
         if p is not None and p.kind == "fmt:thumb" and p.expires >= time.time():
             await self._format_thumb_saved(event, p, thumb)
             return
-        await self.db.set_thumb(event.sender_id, thumb)
-        await self._reply(event, "✅ Thumbnail saved. It will be used for the files I send back.", [[("🗑 Delete", "th:rm"), ("✖ Close", "x:close")]])
+        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")]],
+        )
 
     async def on_gif(self, event: Any) -> None:
         if await self._image_mode(event):
@@ -692,7 +749,7 @@ class App:
     async def cmd_rename(self, event: Any) -> None:
         uid = event.sender_id
         self.pending.pop(uid, None)
-        text, rows = panels.rename_picker(await self.db.list_formats(uid))
+        text, rows = panels.rename_picker(await self.db.list_formats(uid, "manual"))
         await self._reply(event, text, rows)
 
     async def on_media(self, event: Any) -> None:
@@ -720,11 +777,11 @@ class App:
             if hint:
                 await self._reply(event, hint)
             return
-        await self.enqueue(event, event.message)
+        await self.enqueue(event, event.message, fmt=await self.db.get_auto_format(uid))  # None: no auto format, the defaults
 
     async def _media_rename(self, event: Any, mode: Mode) -> None:
         fmt = await self.db.get_format(event.sender_id, mode.data["fid"])
-        if fmt is None:
+        if fmt is None or fmt["kind"] != "manual":
             await self._reply(event, "⚠️ That format was deleted. Use /rename to pick another one, then send the file again.")
             return
         await self.enqueue(event, event.message, fmt=fmt)
@@ -892,7 +949,7 @@ class App:
         s = await self.db.get_settings(uid)
         orig = original_name_of(msg)
         ext = source_ext(msg, orig)
-        template = fmt["template"] if fmt else s["template"]
+        template = fmt["template"] if fmt else default_auto_format()["template"]
         new_name, info = compute_new_name(
             template=template, mode=s["mode"], original_name=orig, original_ext=ext,
             caption=msg.raw_text or "", remove_words=s["remove_words"],
@@ -911,7 +968,7 @@ class App:
         )
         ahead = self.queue.running + self.queue.waiting
         where = "starting soon" if ahead == 0 else f"{ahead} ahead of it"
-        used = f"\n🗂 Format: <b>{esc(clip(fmt['name'], 30))}</b>" if fmt else ""
+        used = f"\n🗂 {'Auto format' if fmt['kind'] == 'auto' else 'Format'}: <b>{esc(clip(fmt['name'], 30))}</b>" if fmt else ""
         job.status_msg = await event.reply(
             f"📥 <b>Queued</b> ({where}){used}\n<code>{esc(clip(new_name, 120))}</code>" + "".join(f"\n⚠️ {esc(n)}" for n in notes),
             buttons=panels.to_buttons([[("✖ Cancel", f"job:x:{job.id}")]]),
@@ -984,10 +1041,11 @@ class App:
             await self._reply(event, "Reply to a file with /check to see the details I can read from its name and caption.")
             return
         s = await self.db.get_settings(event.sender_id)
+        auto = await self.db.get_auto_format(event.sender_id) or default_auto_format()
         name = original_name_of(reply)
         caption = reply.raw_text or ""
         new_name, _info = compute_new_name(
-            template=s["template"], mode=s["mode"], original_name=name, original_ext=source_ext(reply, name),
+            template=auto["template"], mode=s["mode"], original_name=name, original_ext=source_ext(reply, name),
             caption=caption, remove_words=s["remove_words"],
         )
         text = panels.check_text(s["mode"], parse_info(split_ext(name)[0]), parse_caption(caption), new_name)
@@ -1515,7 +1573,7 @@ class App:
             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.db, uid, p.kind, value)
+        ok, msg = await apply_setting(self._store(p.kind), uid, p.kind, value)
         if not ok:
             await self._reply(event, msg + "\n\nTry again, or tap Cancel.")
             return
@@ -1567,6 +1625,10 @@ class App:
             await self._cb_shared(event, uid, parts)
             return
 
+        if head == "au":
+            await self._cb_auto(event, uid, parts)
+            return
+
         if head == "rn":
             await self._cb_rename(event, uid, parts)
             return
@@ -1596,7 +1658,7 @@ class App:
 
         if head == "clr" and len(parts) == 2:
             if parts[1] == "caption":
-                _ok, msg = await apply_setting(self.db, uid, "caption", "reset")
+                _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")
@@ -1609,9 +1671,13 @@ class App:
             await event.answer(clip(plain(msg), 190))
             return
 
-        if head == "th" and len(parts) == 2:
+        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.db.set_thumb(uid, None)
+                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)
@@ -1621,12 +1687,12 @@ class App:
                     await event.answer("Thumbnail deleted.")
                 return
             if parts[1] == "view":
-                data_bytes = await self.db.get_thumb(uid)
+                auto, data_bytes = await self._auto_thumb(uid, fid)
                 if not data_bytes:
-                    await event.answer("You have no thumbnail yet — send me a photo.", alert=True)
+                    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)
+                await self._send_thumb(event.chat_id, data_bytes, auto["id"])
                 return
 
         if data == "help:meta":
@@ -1701,24 +1767,61 @@ class App:
         await event.answer()
 
     # ------------------------------------------------------------ saved formats
+    async def _format_panel(self, uid: int, fmt: Dict[str, Any], share_inline: Optional[bool] = None) -> panels.Panel:
+        """A format's screen: for an auto format it says whether it is the one in use.  ``share_inline`` defaults to whether
+        inline mode is known to be on."""
+        active = False
+        if fmt["kind"] == "auto":
+            current = await self.db.get_auto_format(uid)
+            active = current is not None and current["id"] == fmt["id"]
+        if share_inline is None:
+            share_inline = await self._check_inline()
+        return panels.format_view(fmt, share_inline=share_inline, active=active)
+
     async def _show_format(self, event: Any, uid: int, fid: int, note: str = "") -> bool:
         fmt = await self.db.get_format(uid, fid)
         if fmt is None:
             return False
-        text, rows = panels.format_view(fmt, share_inline=await self._check_inline())
+        text, rows = await self._format_panel(uid, fmt)
         await self._edit_panel(event, f"{note}\n\n{text}" if note else text, rows)
         return True
 
+    async def _show_format_list(self, event: Any, uid: int, kind: str) -> None:
+        formats = await self.db.list_formats(uid, kind)
+        active = await self.db.get_auto_format(uid) if kind == "auto" else None
+        text, rows = panels.formats_menu(formats, MAX_FORMATS, kind, active["id"] if active else 0)
+        await self._edit_panel(event, text, rows)
+
+    async def _cb_auto(self, event: Any, uid: int, parts: List[str]) -> None:
+        """A button of the /start menu's Auto Format screen: use that auto format from now on."""
+        self.pending.pop(uid, None)
+        fmt = await self.db.select_auto_format(uid, int(parts[1])) if len(parts) == 2 and parts[1].isdigit() else None
+        text, rows = await self.panel(uid, "auto")
+        await self._edit_panel(event, text, rows)
+        if fmt is None:
+            await event.answer("That format no longer exists.", alert=True)
+        else:
+            await event.answer(f"Auto format: {clip(fmt['name'], 40)}")
+
     async def _cb_format(self, event: Any, uid: int, parts: List[str]) -> None:
         self.pending.pop(uid, None)  # leaving a prompt open by tapping something else abandons it
         action = parts[1] if len(parts) > 1 else ""
         fid = int(parts[2]) if len(parts) > 2 and parts[2].isdigit() else 0
 
-        if action == "new":
-            if await self.db.count_formats(uid) >= MAX_FORMATS:
-                await event.answer(f"You already have {MAX_FORMATS} formats. Delete one first.", alert=True)
+        if action in ("l", "new"):
+            kind = parts[2] if len(parts) > 2 else ""
+            if kind not in ("auto", "manual"):  # a button of a message from before there were two kinds: start from the choice
+                text, rows = await self.panel(uid, "formats")
+                await self._edit_panel(event, text, rows)
+                await event.answer()
                 return
-            await self._format_prompt(event, uid, "new", 0)
+            if action == "l":
+                await self._show_format_list(event, uid, kind)
+                await event.answer()
+            elif await self.db.count_formats(uid, kind) >= MAX_FORMATS:
+                await event.answer(f"You already have {MAX_FORMATS} {kind} formats. Delete one first.", alert=True)
+            else:
+                await self._format_prompt(event, uid, "new", 0, kind)
             return
 
         fmt = await self.db.get_format(uid, fid) if fid else None
@@ -1743,8 +1846,35 @@ class App:
             await apply_setting(FormatSettings(self.db, fid), uid, "caption", "reset")
             await self._show_format(event, uid, fid)
             await event.answer("Caption reset.")
+        elif action == "use":
+            if await self.db.select_auto_format(uid, fid) is None:
+                await event.answer("Only an auto format can be used for auto rename.", alert=True)
+                return
+            await self._show_format(event, uid, fid, note=f"✅ <b>{esc(clip(fmt['name'], 30))}</b> now renames your files.")
+            await event.answer(f"Auto format: {clip(fmt['name'], 40)}")
+        elif action == "dm":
+            settings = await self.db.get_settings(uid)
+            if not has_default_metadata(settings):
+                await event.answer("Your default metadata is empty. Set it in /metadata first, then apply it.", alert=True)
+                return
+            await self.db.update_format(uid, fid, **default_metadata_changes(settings))
+            await self._show_format(event, uid, fid, note=panels.format_metadata_applied(fmt))
+            await event.answer("Default metadata applied.")
+        elif action == "cp":
+            target = other_kind(fmt["kind"])
+            try:
+                made = await self.db.copy_format(uid, uid, fid, name_max=NAME_MAX, kind=target)
+            except FormatError:  # only "limit" can be raised here
+                await event.answer(f"You already have {MAX_FORMATS} {target} formats. Delete one first.", alert=True)
+                return
+            if made is None:
+                await event.answer("That format no longer exists.", alert=True)
+                return
+            text, rows = panels.format_copied(fmt, made)
+            await self._edit_panel(event, text, rows)
+            await event.answer(f"Copied to your {target} formats.")
         elif action == "sh":  # Share format, shown while inline mode wasn't known to be on: just try the real button
-            text, rows = panels.format_view(fmt, share_inline=True)
+            text, rows = await self._format_panel(uid, fmt, share_inline=True)
             try:
                 await event.edit(text, buttons=panels.to_buttons(rows), parse_mode="html", link_preview=False)
             except errors.MessageNotModifiedError:
@@ -1761,20 +1891,19 @@ class App:
             await event.answer()
         elif action == "ok":
             await self.db.delete_format(uid, fid)
-            text, rows = await self.panel(uid, "formats")
-            await self._edit_panel(event, text, rows)
+            await self._show_format_list(event, uid, fmt["kind"])
             await event.answer(f"Deleted {clip(fmt['name'], 40)}.")
         else:
             await event.answer()
 
-    async def _format_prompt(self, event: Any, uid: int, field: str, fid: int) -> None:
+    async def _format_prompt(self, event: Any, uid: int, field: str, fid: int, kind: str = "") -> None:
         msg_obj = await event.get_message()
         self.pending[uid] = Pending(
             kind=f"fmt:{field}", chat_id=event.chat_id, msg_id=event.message_id, back="formats",
             is_photo=bool(msg_obj is not None and (msg_obj.photo is not None or getattr(msg_obj, "media", None) is not None)),
-            expires=time.time() + self.PENDING_TTL, fid=fid,
+            expires=time.time() + self.PENDING_TTL, fid=fid, fmt_kind=kind,
         )
-        text, rows = panels.format_prompt(field, fid)
+        text, rows = panels.format_prompt(field, fid, kind)
         await self._edit_panel(event, text, rows)
         await event.answer()
 
@@ -1789,8 +1918,11 @@ class App:
             if field in ("new", "name"):
                 ok, value = validate_name(text)
                 if ok and field == "new":
-                    fmt = await self.db.create_format(uid, value, template=(await self.db.get_settings(uid))["template"])
-                    msg = f"✅ Format <b>{esc(value)}</b> created. Now set its template, caption, thumbnail and metadata."
+                    fmt = await self.db.create_format(uid, value, kind=p.fmt_kind or "manual")
+                    msg = (
+                        f"✅ {KIND_LABELS[fmt['kind']]} format <b>{esc(value)}</b> created. Set its template, caption, "
+                        "thumbnail and metadata, or tap Apply default metadata."
+                    )
                     p.fid = fmt["id"]
                 elif ok:
                     if await self.db.update_format(uid, p.fid, name=value) is None:
@@ -1804,7 +1936,7 @@ class App:
             ok = False
             if exc.code == "limit":
                 self.pending.pop(uid, None)
-                await self._reply(event, f"❌ You already have {MAX_FORMATS} formats. Delete one first.")
+                await self._reply(event, f"❌ You already have {MAX_FORMATS} {p.fmt_kind or 'manual'} formats. Delete one first.")
                 return
             msg = "❌ You already have a format with that name."
         except LookupError:
@@ -1835,7 +1967,7 @@ class App:
         if fmt is None:
             await self._reply(event, msg)
             return
-        text, rows = panels.format_view(fmt, share_inline=await self._check_inline())
+        text, rows = await self._format_panel(event.sender_id, fmt)
         limit = 1000 if p.is_photo else 3900
         full = f"{msg}\n\n{text}" if visible_len(msg) + visible_len(text) < limit else f"{msg}\n\n(Open the format to see the update.)"
         try:
@@ -1945,7 +2077,7 @@ class App:
             try:
                 mine = await self.db.copy_format(uid, shared[0], shared[1]["id"], name_max=NAME_MAX)
             except FormatError:  # only "limit" can be raised here
-                await event.answer(f"You already have {MAX_FORMATS} formats. Delete one first.", alert=True)
+                await event.answer(f"You already have {MAX_FORMATS} {shared[1]['kind']} formats. Delete one first.", alert=True)
                 return
         if mine is None:  # the owner deleted it after sharing
             await self._edit_panel(event, panels.SHARE_GONE, [[("✖ Close", "x:close")]])
@@ -1961,8 +2093,8 @@ class App:
         action = parts[1] if len(parts) > 1 else ""
         if action == "p" and len(parts) == 3 and parts[2].isdigit():
             fmt = await self.db.get_format(uid, int(parts[2]))
-            if fmt is None:
-                text, rows = panels.rename_picker(await self.db.list_formats(uid))
+            if fmt is None or fmt["kind"] != "manual":
+                text, rows = panels.rename_picker(await self.db.list_formats(uid, "manual"))
                 await self._edit_panel(event, text, rows)
                 await event.answer("That format no longer exists.", alert=True)
                 return
@@ -1973,7 +2105,7 @@ class App:
         elif action == "menu":
             if self._mode(uid, "rename") is not None:
                 self._end_mode(uid)
-            text, rows = panels.rename_picker(await self.db.list_formats(uid))
+            text, rows = panels.rename_picker(await self.db.list_formats(uid, "manual"))
             await self._edit_panel(event, text, rows)
             await event.answer()
         elif action == "stop":

bot/db.py

@@ -5,6 +5,7 @@ external Postgres (Neon, Supabase, ...).  SQLite works for local testing.
 """
 from __future__ import annotations
 
+import asyncio
 import copy
 import json
 import os
@@ -22,10 +23,12 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 from .errors import FormatError
 from .parser import DEFAULT_TEMPLATE
 
+DEFAULT_CAPTION = "<b>{filename}</b>"  # the new file name in bold
+# The user's own settings.  What names, captions and thumbnails a file gets is not here: it is in the saved formats (below).
+# The default metadata (``metadata_on``, ``meta``, ``keep_*``) is a preset: it applies to auto renames whose format has no
+# metadata of its own, and a format can copy it ("Apply default metadata").
 DEFAULT_SETTINGS: Dict[str, Any] = {
     "mode": "filename",  # filename | caption
-    "template": DEFAULT_TEMPLATE,
-    "caption": "<b>{filename}</b>",
     "file_type": "same",  # same | document | video | audio
     "remove_words": [],
     "metadata_on": False,
@@ -33,19 +36,27 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "keep_audio": [],
     "keep_subtitle": [],
     "target_channel": None,
+    "auto_format": 0,  # id of the auto format that renames the files sent without /rename (0 = none saved: the built-in defaults)
 }
 
 
 # Captions used to be plain.  Whoever still has that default stored gets the bold one, once (see Database._migrate).
 OLD_DEFAULT_CAPTION = "{filename}"
 BOLD_CAPTION_MIGRATION = "migrated:bold_caption"
-
-MAX_FORMATS = 12
-# what a saved /rename format holds; everything else (mode, file type, ...) comes from the user's settings.  A format never
-# borrows the user's own caption: without a caption of its own it sends the new file name in bold.
+# The global template, caption and thumbnail used to be the settings of auto renames.  They are now an auto format of their own.
+AUTO_FORMATS_MIGRATION = "migrated:auto_formats"
+MIGRATED_FORMAT_NAME = "Default"
+
+MAX_FORMATS = 12  # per kind: 12 auto formats and 12 manual ones
+# Two kinds of format: ``auto`` renames every file the user sends (the one in use is picked from the /start menu), ``manual``
+# is picked with /rename for one file.  Formats saved before there were two kinds are manual.
+FORMAT_KINDS = ("auto", "manual")
+DEFAULT_KIND = "manual"
+# what a saved format holds; everything else (mode, file type, ...) comes from the user's settings.  A format never
+# borrows a caption from anywhere else: without a caption of its own it sends the new file name in bold.
 DEFAULT_FORMAT: Dict[str, Any] = {
     "template": DEFAULT_TEMPLATE,
-    "caption": DEFAULT_SETTINGS["caption"],
+    "caption": DEFAULT_CAPTION,
     "meta": {"title": "", "author": "", "artist": "", "audio": "", "subtitle": "", "video": ""},
     "keep_audio": [],
     "keep_subtitle": [],
@@ -65,6 +76,8 @@ class User(Base):
 
     id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=False)
     settings: Mapped[str] = mapped_column(Text, default="{}")
+    # The old global thumbnail.  Thumbnails belong to the formats now; this column is only read once, by the migration
+    # (create_all() never alters a table, so the column stays).
     thumb: Mapped[Optional[bytes]] = mapped_column(LargeBinary, nullable=True)
     files_renamed: Mapped[int] = mapped_column(Integer, default=0)
     bytes_processed: Mapped[int] = mapped_column(BigInteger, default=0)
@@ -144,6 +157,7 @@ def _merge_settings(stored: Dict[str, Any]) -> Dict[str, Any]:
 
 def _merge_format(stored: Dict[str, Any]) -> Dict[str, Any]:
     merged = copy.deepcopy(DEFAULT_FORMAT)
+    merged["kind"] = stored["kind"] if stored.get("kind") in FORMAT_KINDS else DEFAULT_KIND
     for key in ("template", "caption"):
         if isinstance(stored.get(key), str) and stored[key].strip():
             merged[key] = stored[key]
@@ -155,16 +169,30 @@ def _merge_format(stored: Dict[str, Any]) -> Dict[str, Any]:
     return merged
 
 
-def _format_dict(fid: int, name: str, raw: Optional[str], has_thumb: bool) -> Dict[str, Any]:
+def _stored(raw: Optional[str]) -> Dict[str, Any]:
     try:
         stored = json.loads(raw or "{}")
     except ValueError:
-        stored = {}
-    out = _merge_format(stored if isinstance(stored, dict) else {})
+        return {}
+    return stored if isinstance(stored, dict) else {}
+
+
+def _kind_of(raw: Optional[str]) -> str:
+    """The kind of the format a row holds (``auto`` | ``manual``)."""
+    return _merge_format(_stored(raw))["kind"]
+
+
+def _format_dict(fid: int, name: str, raw: Optional[str], has_thumb: bool) -> Dict[str, Any]:
+    out = _merge_format(_stored(raw))
     out.update(id=int(fid), name=name, has_thumb=bool(has_thumb))
     return out
 
 
+def _format_json(fmt: Dict[str, Any]) -> str:
+    """What is stored for a format: its fields and its kind."""
+    return json.dumps({**{k: fmt[k] for k in DEFAULT_FORMAT}, "kind": fmt["kind"]}, ensure_ascii=False)
+
+
 def _free_name(name: str, taken: Iterable[str], name_max: int) -> str:
     """``name``, or ``name (2)``, ``name (3)`` ... when the user already has a format called that (case aside)."""
     used = {n.casefold() for n in taken}
@@ -190,6 +218,7 @@ 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:
@@ -198,19 +227,56 @@ class Database:
 
     async def _migrate(self) -> None:
         """Changes to what earlier versions stored, each made once: a marker in the kv table says it was done."""
-        if await self.kv_get(BOLD_CAPTION_MIGRATION) is not None:
-            return
+        if await self.kv_get(BOLD_CAPTION_MIGRATION) is None:
+            async with self._sessions() as session:
+                for row in (await session.execute(select(User))).scalars().all():
+                    stored = _stored(row.settings)
+                    if stored.get("caption") == OLD_DEFAULT_CAPTION:
+                        stored["caption"] = DEFAULT_CAPTION
+                        row.settings = json.dumps(stored, ensure_ascii=False)
+                await session.commit()
+            await self.kv_set(BOLD_CAPTION_MIGRATION, "done")
+        if await self.kv_get(AUTO_FORMATS_MIGRATION) is None:
+            await self._migrate_auto_formats()
+            await self.kv_set(AUTO_FORMATS_MIGRATION, "done")
+
+    async def _migrate_auto_formats(self) -> None:
+        """The global template, caption and thumbnail become an auto format called "Default", which is the one in use.
+
+        Whoever never changed them has nothing to keep and gets no format (auto renames then use the built-in defaults).  The
+        metadata is not copied: it stays where it is as the default metadata, and an auto format with no metadata of its own uses
+        it while it is On, which is how it always applied to auto renames (and edits to it still count).  Formats that had no
+        thumbnail of their own used the global one: they keep using it.
+        A user is migrated once: the ``auto_format`` key marks it (the rows are rewritten in one transaction).
+        """
         async with self._sessions() as session:
             for row in (await session.execute(select(User))).scalars().all():
                 try:
                     stored = json.loads(row.settings or "{}")
                 except ValueError:
                     continue
-                if isinstance(stored, dict) and stored.get("caption") == OLD_DEFAULT_CAPTION:
-                    stored["caption"] = DEFAULT_SETTINGS["caption"]
-                    row.settings = json.dumps(stored, ensure_ascii=False)
+                if not isinstance(stored, dict) or "auto_format" in stored:
+                    continue
+                old = _merge_format({"template": stored.get("template"), "caption": stored.get("caption")})
+                thumb = bytes(row.thumb) if row.thumb else None
+                keeps_something = old["template"] != DEFAULT_FORMAT["template"] or old["caption"] != DEFAULT_FORMAT["caption"] or thumb
+                fid = 0
+                if keeps_something:
+                    made = Format(user_id=row.id, name=MIGRATED_FORMAT_NAME, data=_format_json({**old, "kind": "auto"}), thumb=thumb)
+                    session.add(made)
+                    await session.flush()
+                    fid = made.id
+                if thumb:
+                    for fmt in (await session.execute(select(Format).where(Format.user_id == row.id, Format.thumb.is_(None)))).scalars():
+                        if _kind_of(fmt.data) == "manual":
+                            fmt.thumb = thumb
+                row.thumb = None
+                stored.pop("template", None)
+                stored.pop("caption", None)
+                stored["auto_format"] = fid
+                row.settings = json.dumps(stored, ensure_ascii=False)
             await session.commit()
-        await self.kv_set(BOLD_CAPTION_MIGRATION, "done")
+        self._cache.clear()
 
     async def close(self) -> None:
         await self.engine.dispose()
@@ -255,22 +321,6 @@ class Database:
         self._cache[uid] = current
         return copy.deepcopy(current)
 
-    async def set_thumb(self, uid: int, data: Optional[bytes]) -> None:
-        async with self._sessions() as session:
-            row = await self._get_or_create(session, uid)
-            row.thumb = data
-            await session.commit()
-
-    async def get_thumb(self, uid: int) -> Optional[bytes]:
-        async with self._sessions() as session:
-            row = await session.get(User, uid)
-            return bytes(row.thumb) if row is not None and row.thumb else None
-
-    async def has_thumb(self, uid: int) -> bool:
-        async with self._sessions() as session:
-            result = await session.execute(select(User.thumb.isnot(None)).where(User.id == uid))
-            return bool(result.scalar())
-
     async def record_job(self, uid: int, size: int) -> None:
         async with self._sessions() as session:
             row = await self._get_or_create(session, uid)
@@ -291,17 +341,18 @@ class Database:
             ).one()
             return int(row[0]), int(row[1])
 
-    # ----- saved /rename formats ------------------------------------------------------
-    async def list_formats(self, uid: int) -> List[Dict[str, Any]]:
+    # ----- saved formats (auto and manual) ----------------------------------------------
+    async def list_formats(self, uid: int, kind: Optional[str] = None) -> List[Dict[str, Any]]:
+        """The user's formats, oldest first: all of them, or only those of one ``kind``."""
         async with self._sessions() as session:
             result = await session.execute(
                 select(Format.id, Format.name, Format.data, Format.thumb.isnot(None)).where(Format.user_id == uid).order_by(Format.id)
             )
-            return [_format_dict(r[0], r[1], r[2], r[3]) for r in result.all()]
+            formats = [_format_dict(r[0], r[1], r[2], r[3]) for r in result.all()]
+        return [f for f in formats if kind is None or f["kind"] == kind]
 
-    async def count_formats(self, uid: int) -> int:
-        async with self._sessions() as session:
-            return int((await session.execute(select(func.count()).select_from(Format).where(Format.user_id == uid))).scalar() or 0)
+    async def count_formats(self, uid: int, kind: Optional[str] = None) -> int:
+        return len(await self.list_formats(uid, kind))
 
     async def get_format(self, uid: int, fid: int) -> Optional[Dict[str, Any]]:
         async with self._sessions() as session:
@@ -311,23 +362,33 @@ class Database:
             r = result.first()
             return _format_dict(r[0], r[1], r[2], r[3]) if r else None
 
-    async def create_format(self, uid: int, name: str, template: Optional[str] = None) -> Dict[str, Any]:
-        """Add a format; raises ``FormatError`` when the user already has ``MAX_FORMATS`` or the name is taken."""
+    @staticmethod
+    async def _names(session: Any, uid: int, kind: str, *, except_id: int = 0) -> List[str]:
+        """The names of the user's formats of one kind (a name only has to be free among its own kind)."""
+        rows = await session.execute(select(Format.id, Format.name, Format.data).where(Format.user_id == uid))
+        return [r[1] for r in rows.all() if r[0] != except_id and _kind_of(r[2]) == kind]
+
+    async def create_format(
+        self, uid: int, name: str, template: Optional[str] = None, kind: str = DEFAULT_KIND
+    ) -> Dict[str, Any]:
+        """Add a format of ``kind``; raises ``FormatError`` when the user already has ``MAX_FORMATS`` of that kind or the name is taken."""
+        if kind not in FORMAT_KINDS:
+            raise KeyError(kind)
         async with self._sessions() as session:
-            names = list((await session.execute(select(Format.name).where(Format.user_id == uid))).scalars())
+            names = await self._names(session, uid, kind)
             if len(names) >= MAX_FORMATS:
                 raise FormatError("limit")
             if name.casefold() in {n.casefold() for n in names}:
                 raise FormatError("taken")
-            data = copy.deepcopy(DEFAULT_FORMAT)
+            data = {**copy.deepcopy(DEFAULT_FORMAT), "kind": kind}
             if template:
                 data["template"] = template
-            row = Format(user_id=uid, name=name, data=json.dumps(data, ensure_ascii=False))
+            row = Format(user_id=uid, name=name, data=_format_json(data))
             session.add(row)
             await session.flush()
-            fid = row.id
+            fid, raw = row.id, row.data
             await session.commit()
-        return _format_dict(fid, name, json.dumps(data, ensure_ascii=False), False)
+        return _format_dict(fid, name, raw, False)
 
     async def update_format(self, uid: int, fid: int, **changes: Any) -> Optional[Dict[str, Any]]:
         """Change ``name``, ``template``, ``caption``, ``keep_audio``, ``keep_subtitle`` or merge a ``meta`` dict; ``None`` if it is gone."""
@@ -338,10 +399,7 @@ class Database:
             current = _format_dict(row.id, row.name, row.data, False)
             for key, value in changes.items():
                 if key == "name":
-                    others = (
-                        await session.execute(select(Format.name).where(Format.user_id == uid, Format.id != fid))
-                    ).scalars()
-                    if value.casefold() in {n.casefold() for n in others}:
+                    if value.casefold() in {n.casefold() for n in await self._names(session, uid, current["kind"], except_id=fid)}:
                         raise FormatError("taken")
                     row.name = value
                 elif key == "meta":
@@ -350,7 +408,7 @@ class Database:
                     current[key] = value
                 else:
                     raise KeyError(key)
-            row.data = json.dumps({k: current[k] for k in DEFAULT_FORMAT}, ensure_ascii=False)
+            row.data = _format_json(current)
             has_thumb = row.thumb is not None
             await session.commit()
             return _format_dict(row.id, row.name, row.data, has_thumb)
@@ -415,25 +473,73 @@ class Database:
             ).first()
             return (int(share.user_id), _format_dict(r[0], r[1], r[2], r[3])) if r else None
 
-    async def copy_format(self, uid: int, owner_id: int, fid: int, name_max: int = 64) -> Optional[Dict[str, Any]]:
+    async def copy_format(
+        self, uid: int, owner_id: int, fid: int, name_max: int = 64, kind: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
         """Give ``uid`` a copy of ``owner_id``'s format (thumbnail included), under a free name.
 
-        ``None`` when that format is gone; ``FormatError("limit")`` when ``uid`` already has ``MAX_FORMATS``.
+        The copy is of the same kind as the original unless ``kind`` says otherwise: that is how a user copies an auto format
+        to the manual ones and the other way round (``owner_id`` is then the user themselves).  ``None`` when that format is
+        gone; ``FormatError("limit")`` when ``uid`` already has ``MAX_FORMATS`` of that kind.
         """
+        if kind is not None and kind not in FORMAT_KINDS:
+            raise KeyError(kind)
         async with self._sessions() as session:
             source = await session.get(Format, fid)
             if source is None or source.user_id != owner_id:
                 return None
-            names = list((await session.execute(select(Format.name).where(Format.user_id == uid))).scalars())
+            target = kind or _kind_of(source.data)
+            names = await self._names(session, uid, target)
             if len(names) >= MAX_FORMATS:
                 raise FormatError("limit")
             name = _free_name(source.name, names, name_max)
-            row = Format(user_id=uid, name=name, data=source.data, thumb=source.thumb)
+            data = _format_json({**_merge_format(_stored(source.data)), "kind": target})
+            row = Format(user_id=uid, name=name, data=data, thumb=source.thumb)
             session.add(row)
             await session.flush()
-            new_id, raw, has_thumb = row.id, source.data, source.thumb is not None
+            new_id, has_thumb = row.id, source.thumb is not None
             await session.commit()
-        return _format_dict(new_id, name, raw, has_thumb)
+        return _format_dict(new_id, name, data, has_thumb)
+
+    # ----- the auto format in use ----------------------------------------------------------
+    async def get_auto_format(self, uid: int) -> Optional[Dict[str, Any]]:
+        """The auto format that renames the user's files, or ``None`` when they have none (the built-in defaults are used then).
+
+        Having auto formats always means having one in use: when the chosen one is gone (deleted) or was never chosen, the oldest
+        takes over and is remembered.
+        """
+        chosen = (await self.get_settings(uid))["auto_format"]
+        formats = await self.list_formats(uid, "auto")
+        if not formats:
+            if chosen:
+                await self.update_settings(uid, auto_format=0)
+            return None
+        current = next((f for f in formats if f["id"] == chosen), formats[0])
+        if current["id"] != chosen:
+            await self.update_settings(uid, auto_format=current["id"])
+        return current
+
+    async def select_auto_format(self, uid: int, fid: int) -> Optional[Dict[str, Any]]:
+        """Use this auto format for the user's files from now on; ``None`` when there is no such auto format."""
+        fmt = await self.get_format(uid, fid)
+        if fmt is None or fmt["kind"] != "auto":
+            return None
+        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 ``/template``, ``/caption`` 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]:

bot/formats.py

@@ -1,18 +1,24 @@
-"""Saved /rename formats: the pieces shared by the menus, the handlers and the pipeline.
+"""Saved formats (auto and manual): the pieces shared by the menus, the handlers and the pipeline.
 
 A format is a named bundle of a naming template, a caption, a thumbnail, the six metadata titles and the Keep
 Audio / Keep Subtitle lists.  Every other setting (mode, file type, remove words, target channel) still comes
-from the user's normal auto-rename settings.  The caption never does: a format that was given none sends the new
-file name in bold, whatever caption the user set for their own renames.
+from the user's normal settings.  The caption never does: a format that was given none sends the new
+file name in bold.
+
+There are two kinds, twelve of each.  An **auto** format renames every file the user sends (the one in use is chosen from
+the /start menu); a **manual** format is chosen with /rename and renames one file.  The user's default metadata is a preset:
+a format can copy it ("Apply default metadata"), and an auto format that has no metadata of its own uses it while it is On.
 """
 from __future__ import annotations
 
 import copy
 from typing import Any, Dict, Optional, Tuple
 
-from .db import DEFAULT_SETTINGS, Database
+from .db import DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_KIND, DEFAULT_SETTINGS, Database
 
 NAME_MAX = 30
+KIND_LABELS = {"auto": "Auto", "manual": "Manual"}
+KIND_ICONS = {"auto": "🤖", "manual": "✋"}
 # format field -> the kind settings_ops.apply_setting() understands
 FIELD_KINDS: Dict[str, str] = {
     "template": "template", "caption": "caption",
@@ -23,6 +29,10 @@ FIELD_KINDS: Dict[str, str] = {
 _EDITABLE = ("template", "caption", "meta", "keep_audio", "keep_subtitle")
 
 
+def other_kind(kind: str) -> str:
+    return "manual" if kind == "auto" else "auto"
+
+
 def validate_name(text: Optional[str]) -> Tuple[bool, str]:
     """``(True, cleaned name)`` or ``(False, html error)``."""
     name = " ".join((text or "").split())
@@ -37,26 +47,59 @@ def has_metadata(fmt: Dict[str, Any]) -> bool:
     return any(fmt["meta"].values()) or bool(fmt["keep_audio"] or fmt["keep_subtitle"])
 
 
-def apply_format(settings: Dict[str, Any], fmt: Dict[str, Any]) -> Dict[str, Any]:
+def has_default_metadata(settings: Dict[str, Any]) -> bool:
+    """Has the user set any default metadata (a title or the like, or a Keep Audio / Keep Subtitle list)?"""
+    return any(settings["meta"].values()) or bool(settings["keep_audio"] or settings["keep_subtitle"])
+
+
+def default_metadata_changes(settings: Dict[str, Any]) -> Dict[str, Any]:
+    """What ``Database.update_format`` takes to make a format's metadata the user's default metadata."""
+    return dict(meta=dict(settings["meta"]), keep_audio=list(settings["keep_audio"]), keep_subtitle=list(settings["keep_subtitle"]))
+
+
+def default_auto_format() -> Dict[str, Any]:
+    """What renames the files of a user who has no auto format: the built-in template and caption, no thumbnail, no metadata."""
+    out = copy.deepcopy(DEFAULT_FORMAT)
+    out.update(kind="auto", id=0, name="", has_thumb=False)
+    return out
+
+
+def apply_format(settings: Dict[str, Any], fmt: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """The user's settings with the format's template, caption, metadata and keep lists laid over them.
 
-    Metadata is on whenever the format sets anything, whatever the global Metadata switch says: the format
-    carries its own metadata, and a format with none leaves the file alone (no ffmpeg pass).
+    ``fmt`` is ``None`` for an auto rename of a user who has no auto format: the built-in defaults.
+
+    Metadata is on whenever the format sets anything, whatever the Metadata switch says: the format carries its own
+    metadata.  A manual format with none leaves the file alone (no ffmpeg pass).  An auto format with none leaves the user's
+    default metadata in charge: it applies while its switch is On, as it always did for auto renames.
     """
+    fmt = fmt or default_auto_format()
     out = copy.deepcopy(settings)
     out["template"] = fmt["template"]
-    out["caption"] = fmt.get("caption") or DEFAULT_SETTINGS["caption"]  # never the user's own caption
+    out["caption"] = fmt.get("caption") or DEFAULT_CAPTION  # never a caption from anywhere else
+    if has_metadata(fmt) or fmt.get("kind", DEFAULT_KIND) == "manual":
+        out["meta"] = dict(fmt["meta"])
+        out["keep_audio"] = list(fmt["keep_audio"])
+        out["keep_subtitle"] = list(fmt["keep_subtitle"])
+        out["metadata_on"] = has_metadata(fmt)
+    return out
+
+
+def _as_settings(fmt: Dict[str, Any]) -> Dict[str, Any]:
+    """A format shaped like the user's settings, which is what ``apply_setting`` reads."""
+    out = copy.deepcopy(DEFAULT_SETTINGS)
+    out.update(
+        template=fmt["template"], caption=fmt["caption"], keep_audio=list(fmt["keep_audio"]),
+        keep_subtitle=list(fmt["keep_subtitle"]), metadata_on=True,
+    )
     out["meta"] = dict(fmt["meta"])
-    out["keep_audio"] = list(fmt["keep_audio"])
-    out["keep_subtitle"] = list(fmt["keep_subtitle"])
-    out["metadata_on"] = has_metadata(fmt)
     return out
 
 
 class FormatSettings:
     """Edits one saved format through the two methods ``apply_setting`` uses on ``Database``.
 
-    That keeps a single copy of every validation rule and message for the global settings and the formats.
+    That keeps a single copy of every validation rule and message for the user's settings and the formats.
     Metadata is always "on" here, so the "metadata is off" notes never show for a format.
     """
 
@@ -68,16 +111,30 @@ class FormatSettings:
         fmt = await self.db.get_format(uid, self.fid)
         if fmt is None:
             raise LookupError("that format no longer exists")
-        out = copy.deepcopy(DEFAULT_SETTINGS)
-        out.update(
-            template=fmt["template"], caption=fmt["caption"], keep_audio=list(fmt["keep_audio"]),
-            keep_subtitle=list(fmt["keep_subtitle"]), metadata_on=True,
-        )
-        out["meta"] = dict(fmt["meta"])
-        return out
+        return _as_settings(fmt)
 
     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}
         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: ``/template``, ``/caption`` and their 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/panels.py

@@ -6,10 +6,11 @@ limit because the home banner makes every panel a photo caption.
 """
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, List, Sequence, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
 
 from . import richtext
-from .db import DEFAULT_SETTINGS
+from .db import DEFAULT_CAPTION, DEFAULT_FORMAT
+from .formats import KIND_ICONS, KIND_LABELS, has_metadata, other_kind
 from .media import LANGUAGES, canonical_lang
 from .parser import CAPTION_VARS, TEMPLATE_VARS
 from .utils import clip, code_each, esc
@@ -22,6 +23,11 @@ DOT = "◈"
 # The variable lists shown in the panels and prompts: every variable is its own <code> block, so tapping one copies only it.
 TEMPLATE_VARIABLES = code_each("{%s}" % name for name in TEMPLATE_VARS)
 CAPTION_VARIABLES = code_each("{%s}" % name for name in CAPTION_VARS if name != "ext")  # {ext} was never listed for captions
+# What {1episode} ... {3episode} do, in one line (they are the episode with zeros in front, 2 to 4 digits wide)
+EPISODE_ZEROS = (
+    "Zeros in front of the episode: <code>{1episode}</code> makes it 2 digits (4 → 04), <code>{2episode}</code> 3 digits (4 → 004), "
+    "<code>{3episode}</code> 4 digits (4 → 0004). A number that already has that many digits stays as it is."
+)
 
 
 INLINE = "inline:"  # a button whose data starts with this opens Telegram's chat picker, with "@bot <the rest>" typed in the chat
@@ -80,26 +86,39 @@ def fmt_tokens(tokens: Iterable[str]) -> str:
 # ---------------------------------------------------------------------------
 
 
-def home(s: Dict[str, Any], *, owner: bool) -> Panel:
+def _auto_name(auto: Optional[Dict[str, Any]]) -> str:
+    """The auto format in use, for a panel; ``auto`` is ``None`` for someone who has none."""
+    return f"<b>{esc(clip(auto['name'], 30))}</b>" if auto else "none saved (the default is used)"
+
+
+def _template_of(auto: Optional[Dict[str, Any]]) -> str:
+    return auto["template"] if auto else DEFAULT_FORMAT["template"]
+
+
+def home(s: Dict[str, Any], *, owner: bool, auto: Optional[Dict[str, Any]] = None) -> Panel:
+    """The main menu.  ``auto`` is the auto format in use (``None``: the user has none)."""
     channel = f"channel <code>{s['target_channel']}</code>" if s.get("target_channel") else "this chat"
+    metadata_on = s["metadata_on"] or bool(auto and has_metadata(auto))  # a format with metadata of its own writes it, switch or not
     text = (
         "<b>🏷 Auto Rename Bot</b>\n\n"
-        "Send me a file (document, video or audio) and I'll rename it with your template and send it back.\n\n"
+        "Send me a file (document, video or audio) and I'll rename it with your auto format and send it back.\n\n"
         f"<b>Mode:</b> <code>{s['mode'].upper()}</code> · <b>Type:</b> <code>{s['file_type'].upper()}</code>"
-        f" · <b>Metadata:</b> <code>{'ON' if s['metadata_on'] else 'OFF'}</code>\n"
-        f"<b>Template:</b> {_code(s['template'], 120)}\n"
+        f" · <b>Metadata:</b> <code>{'ON' if metadata_on else 'OFF'}</code>\n"
+        f"<b>Auto format:</b> {_auto_name(auto)}\n"
+        f"<b>Template:</b> {_code(_template_of(auto), 120)}\n"
         f"<b>Send to:</b> {channel}"
     )
     rows: List[Row] = [
-        [("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 []),
+        [("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 []),
         [("✖ Close", "x:close")],
     ]
     return text, rows
 
 
-def rename(s: Dict[str, Any]) -> Panel:
+def rename(s: Dict[str, Any], auto: Optional[Dict[str, Any]] = None) -> Panel:
     words = ", ".join(s["remove_words"]) or "—"
     text = (
         "<b>RENAME MODE</b>\n\n"
@@ -107,7 +126,7 @@ def rename(s: Dict[str, Any]) -> Panel:
         "Caption mode reads details from the message caption.\n\n"
         f"Current mode: <code>{s['mode'].upper()}</code>\n"
         "Command: /mode\n\n"
-        f"<b>Template:</b> {_code(s['template'], 120)}\n"
+        f"<b>Template</b> of the auto format {_auto_name(auto)}: {_code(_template_of(auto), 120)}\n"
         f"<b>Remove words:</b> {esc(clip(words, 100))}"
     )
     rows: List[Row] = [
@@ -118,19 +137,22 @@ def rename(s: Dict[str, Any]) -> Panel:
     return text, rows
 
 
-def caption(s: Dict[str, Any], has_thumb: bool) -> Panel:
+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\n"
-        f"<b>Caption template:</b> {richtext.preview(s['caption'], 160)}\n"
+        "<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 your thumbnail."
+        "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", "th:view"), ("Delete Thumb", "th:del")],
+        [("View Thumb", f"th:view{thumb}"), ("Delete Thumb", f"th:del{thumb}")],
     ] + nav("home")
     return text, rows
 
@@ -138,12 +160,14 @@ def caption(s: Dict[str, Any], has_thumb: bool) -> Panel:
 def metadata(s: Dict[str, Any]) -> Panel:
     m = s["meta"]
     on = s["metadata_on"]
-    lines = [f"<b>🏷 Your metadata is currently: {'On' if on else 'Off'}</b>", ""]
+    lines = [f"<b>🏷 Your default metadata is currently: {'On' if on else 'Off'}</b>", ""]
     for label, key in (("Title", "title"), ("Author", "author"), ("Artist", "artist"),
                        ("Audio", "audio"), ("Subtitle", "subtitle"), ("Video", "video")):
         lines.append(f"{DOT} <b>{label}</b> ▸ {_code(m.get(key, ''), 60)}")
     lines.append(f"{DOT} <b>Keep Audio</b> ▸ {esc(fmt_tokens(s['keep_audio']))}")
     lines.append(f"{DOT} <b>Keep Subtitle</b> ▸ {esc(fmt_tokens(s['keep_subtitle']))}")
+    lines += ["", "Auto renames use it when their format has no metadata of its own. To put it in a format, tap "
+                  "<b>Apply default metadata</b> on the format."]
     rows: List[Row] = [
         [(_check("On", on), "set:meta:on"), (_check("Off", not on), "set:meta:off")],
         [("Title", "in:mt_title"), ("Author", "in:mt_author"), ("Artist", "in:mt_artist")],
@@ -209,17 +233,17 @@ def filetype(s: Dict[str, Any]) -> Panel:
 def help_panel() -> Panel:
     text = (
         "<b>How to use</b>\n\n"
-        "1. Send a file — I rename it with your template and send it back.\n"
-        "2. /formats — save up to 12 named formats (template, caption, thumbnail, metadata, tracks) and share them; "
-        "/rename — pick one, then send a file (send /rename again for the next one).\n"
-        "3. /template and /caption — set the naming and caption templates.\n"
-        "4. /mode — read details from the file name or the caption.\n"
-        "5. /metadata, /keepaudio, /keepsubtitle — tags and track clean-up.\n"
-        "6. /filetype — send as document, video or audio.\n"
-        "7. Send a photo — it becomes your thumbnail.\n"
-        "8. /sequence then /sort — put files in episode order.\n"
-        "9. /check, /mediainfo, /ethumb, /resize, /speed — inspect files and images.\n"
-        "10. /queue and /cancel — manage running jobs.\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. /template, /caption — change those of 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"
         f"Template variables: {TEMPLATE_VARIABLES}\n"
         "A [bracket] group is dropped when a variable inside it is empty."
     )
@@ -254,11 +278,12 @@ FORMAT_FIELD_LABELS = (
 )
 
 
-def _format_buttons(formats: Sequence[Dict[str, Any]], prefix: str) -> List[Row]:
+def _format_buttons(formats: Sequence[Dict[str, Any]], prefix: str, active_id: int = 0) -> List[Row]:
+    """One button per format, two to a row; the one in use (``active_id``) is ticked."""
     rows: List[Row] = []
     row: Row = []
     for f in formats:
-        row.append((clip(f["name"], 24), f"{prefix}:{f['id']}"))
+        row.append((_check(clip(f["name"], 24), f["id"] == active_id), f"{prefix}:{f['id']}"))
         if len(row) == 2:
             rows.append(row)
             row = []
@@ -267,26 +292,64 @@ def _format_buttons(formats: Sequence[Dict[str, Any]], prefix: str) -> List[Row]
     return rows
 
 
-def formats_menu(formats: Sequence[Dict[str, Any]], limit: int) -> Panel:
+def formats_home(auto_count: int, manual_count: int, limit: int) -> Panel:
+    """/formats: the two kinds of format, to choose from."""
     text = (
-        f"<b>🗂 FORMATS</b> ({len(formats)}/{limit})\n\n"
+        "<b>🗂 FORMATS</b>\n\n"
         "A format saves its own template, caption, thumbnail, metadata titles and Keep Audio / Keep Subtitle lists "
-        "under a name, like <i>One Piece</i> or <i>Dragon Ball</i>.\n"
-        "Tap one to view or edit it, then use /rename to apply it to your files."
+        f"under a name, like <i>One Piece</i>. You can keep {limit} of each kind:\n\n"
+        "🤖 <b>Auto rename</b> — renames every file you send me. Choose the one in use in the /start menu.\n"
+        "✋ <b>Manual rename</b> — you pick one with /rename, for a single file.\n\n"
+        "A format can be copied from one kind to the other."
     )
+    rows: List[Row] = [[(f"🤖 Auto rename ({auto_count}/{limit})", "fm:l:auto"), (f"✋ Manual rename ({manual_count}/{limit})", "fm:l:manual")]]
+    return text, rows + nav("home")
+
+
+def formats_menu(formats: Sequence[Dict[str, Any]], limit: int, kind: str = "manual", active_id: int = 0) -> Panel:
+    """The formats of one kind (``active_id``: the auto format in use)."""
+    if kind == "auto":
+        intro = "These rename every file you send me. The one marked ✅ is in use: tap a format to view or edit it."
+    else:
+        intro = "You pick one of these with /rename, for a single file. Tap a format to view or edit it."
+    text = f"<b>{KIND_ICONS[kind]} {KIND_LABELS[kind].upper()} FORMATS</b> ({len(formats)}/{limit})\n\n{intro}"
     if not formats:
-        text += "\n\nYou have no formats yet."
-    rows = _format_buttons(formats, "fm:v")
+        text += f"\n\nYou have no {kind} formats yet."
+    rows = _format_buttons(formats, "fm:v", active_id)
     if len(formats) < limit:
-        rows.append([("➕ New format", "fm:new")])
+        rows.append([("➕ New format", f"fm:new:{kind}")])
     else:
-        text += f"\n\nYou have all {limit} formats. Delete one to add another."
-    return text, rows + nav("home")
+        text += f"\n\nYou have all {limit} {kind} formats. Delete one to add another."
+    return text, rows + nav("formats")
+
+
+def auto_menu(formats: Sequence[Dict[str, Any]], active_id: int, limit: int) -> Panel:
+    """The /start menu's Auto Format screen: choose the auto format that renames your files."""
+    text = (
+        "<b>🤖 AUTO RENAME FORMAT</b>\n\n"
+        "Every file you send me is renamed with the format marked ✅. Tap another one to use it instead.\n"
+        "For a single file with a manual format, use /rename."
+    )
+    if not formats:
+        text += (
+            "\n\nYou have no auto formats yet, so the default template is used. Create one to set your own template, "
+            "caption, thumbnail and metadata."
+        )
+    rows = _format_buttons(formats, "au", active_id)
+    if active_id:
+        rows.append([("✏️ Edit the one in use", f"fm:v:{active_id}")])
+    last: Row = [("⚙️ Manage", "fm:l:auto")]
+    if len(formats) < limit:
+        last.append(("➕ New format", "fm:new:auto"))
+    return text, rows + [last] + nav("home")
 
 
 def _custom_caption(fmt: Dict[str, Any]) -> bool:
     """Has the format a caption of its own?  Otherwise it sends the new file name in bold."""
-    return fmt["caption"] != DEFAULT_SETTINGS["caption"]
+    return fmt["caption"] != DEFAULT_CAPTION
+
+
+THUMB_NONE = "— (a frame of the video is used)"
 
 
 def _format_lines(fmt: Dict[str, Any], *, thumb_yes: str, thumb_no: str) -> List[str]:
@@ -304,12 +367,21 @@ def _format_lines(fmt: Dict[str, Any], *, thumb_yes: str, thumb_no: str) -> List
     return lines
 
 
-def format_view(fmt: Dict[str, Any], *, share_inline: bool = False) -> Panel:
-    """A format's screen.  ``share_inline``: the Share format button opens the chat picker straight away; that only works
-    while inline mode is on for the bot (Telegram refuses the message otherwise), so without it the button explains how."""
-    lines = [f"<b>🗂 {esc(clip(fmt['name'], 30))}</b>", ""]
-    lines += _format_lines(fmt, thumb_yes="✅ saved", thumb_no="— (your default thumbnail is used)")
-    lines += ["", "Use it with /rename. Mode, file type and the rest come from your normal settings."]
+def format_view(fmt: Dict[str, Any], *, share_inline: bool = False, active: bool = False) -> Panel:
+    """A format's screen.  ``active``: it is the auto format in use.  ``share_inline``: the Share format button opens the chat
+    picker straight away; that only works while inline mode is on for the bot (Telegram refuses the message otherwise), so
+    without it the button explains how."""
+    kind = fmt.get("kind", "manual")
+    lines = [f"<b>🗂 {esc(clip(fmt['name'], 30))}</b> · {KIND_ICONS[kind]} {KIND_LABELS[kind]}", ""]
+    lines += _format_lines(fmt, thumb_yes="✅ saved", thumb_no=THUMB_NONE)
+    if kind == "manual":
+        lines += ["", "Use it with /rename. Mode, file type and the rest come from your normal settings."]
+    elif active:
+        lines += ["", "✅ In use: every file you send is renamed with it."]
+    else:
+        lines += ["", "Not in use. Tap Use for auto rename to rename your files with it."]
+    if kind == "auto" and not has_metadata(fmt):
+        lines.append("No metadata of its own: your default metadata is used while it is On.")
     fid = fmt["id"]
     thumb_row: Row = [("Thumbnail", f"fm:th:{fid}")]
     if fmt.get("has_thumb"):
@@ -324,41 +396,82 @@ def format_view(fmt: Dict[str, Any], *, share_inline: bool = False) -> Panel:
         [("Title", f"fm:in:{fid}:title"), ("Author", f"fm:in:{fid}:author"), ("Artist", f"fm:in:{fid}:artist")],
         [("Audio", f"fm:in:{fid}:audio"), ("Subtitle", f"fm:in:{fid}:subtitle"), ("Video", f"fm:in:{fid}:video")],
         [("Keep Audio", f"fm:in:{fid}:keep_audio"), ("Keep Subtitle", f"fm:in:{fid}:keep_subtitle")],
+        [("🏷 Apply default metadata", f"fm:dm:{fid}")],
+        [(f"📋 Copy to {other_kind(kind)} formats", f"fm:cp:{fid}")],
+    ]
+    if kind == "auto" and not active:
+        rows.append([("✅ Use for auto rename", f"fm:use:{fid}")])
+    rows += [
         [("📤 Share format", INLINE + share_query(fid) if share_inline else f"fm:sh:{fid}")],
         [("🗑 Delete format", f"fm:del:{fid}")],
-    ] + nav("formats")
+        [("◀ Back", f"fm:l:{kind}"), ("🏠 Home", "m:home"), ("✖ Close", "x:close")],
+    ]
     return "\n".join(lines), rows
 
 
+def format_copied(source: Dict[str, Any], copy: Dict[str, Any]) -> Panel:
+    """What copying a format to the other kind shows."""
+    kind = copy["kind"]
+    text = (
+        f"✅ <b>{esc(clip(source['name'], 30))}</b> is copied to your {kind} formats as <b>{esc(clip(copy['name'], 30))}</b>.\n"
+        "The copy is a format of its own: change it without touching the original."
+    )
+    rows: List[Row] = [
+        [("📂 Open the copy", f"fm:v:{copy['id']}")],
+        [("◀ Back to the original", f"fm:v:{source['id']}")],
+        [("✖ Close", "x:close")],
+    ]
+    return text, rows
+
+
+def format_metadata_applied(fmt: Dict[str, Any]) -> str:
+    """The note shown above a format after "Apply default metadata"."""
+    return f"✅ Your default metadata is now in <b>{esc(clip(fmt['name'], 30))}</b>."
+
+
 INLINE_OFF = "Sharing needs inline mode. In @BotFather: /mybots → this bot → Bot Settings → Inline Mode → Turn on. Then tap Share format again."
 SHARE_GONE = "⚠️ <b>That shared format isn't available anymore.</b>\nThe person who shared it deleted it. Ask them to share it again."
 
 
+def _a(kind: str) -> str:
+    """``An auto`` / ``A manual``"""
+    return f"{'An' if kind == 'auto' else 'A'} {kind}"
+
+
 def share_card(fmt: Dict[str, Any]) -> Tuple[str, str, str]:
     """``(title, description, html text)`` of the card that is sent to the chat the owner picked."""
     name = clip(fmt["name"], 30)
+    kind = fmt.get("kind", "manual")
     return (
         f"🗂 {name}",
         "Tap to send this format to the chat",
-        f"📦 <b>{esc(name)}</b>\nA rename format for this bot. Open it to see what's in it and add it to your own formats.",
+        f"📦 <b>{esc(name)}</b>\n{_a(kind)} rename format for this bot. Open it to see what's in it and add it to your own formats.",
     )
 
 
 def shared_format(fmt: Dict[str, Any], token: str, *, mine: bool = False) -> Panel:
     """What opening a shared format shows: what is in it, and a button to add it to your own formats."""
-    lines = [f"<b>📦 {esc(clip(fmt['name'], 30))}</b>", "This is your own format." if mine else "A rename format shared with you.", ""]
-    lines += _format_lines(fmt, thumb_yes="✅ included", thumb_no="— (your default thumbnail is used)")
+    kind = fmt.get("kind", "manual")
+    lines = [
+        f"<b>📦 {esc(clip(fmt['name'], 30))}</b> · {KIND_ICONS[kind]} {KIND_LABELS[kind]}",
+        "This is your own format." if mine else f"{_a(kind)} rename format shared with you.",
+        "",
+    ]
+    lines += _format_lines(fmt, thumb_yes="✅ included", thumb_no=THUMB_NONE)
+    use = "/rename" if kind == "manual" else "auto rename"
     if mine:
         lines += ["", "Whoever you send it to can look at it here and add a copy to their own formats."]
         rows: List[Row] = [[("🗂 Open format", f"fm:v:{fmt['id']}")]]
     else:
-        lines += ["", "Add it to your formats to use it with /rename. You can change anything in your copy afterwards."]
+        lines += ["", f"Add it to your {kind} formats to use it for {use}. You can change anything in your copy afterwards."]
         rows = [[("➕ Add to my formats", f"fs:add:{token}")]]
     return "\n".join(lines), rows + [[("✖ Close", "x:close")]]
 
 
 def shared_added(fmt: Dict[str, Any]) -> Panel:
-    text = f"✅ <b>{esc(clip(fmt['name'], 30))}</b> is now in your formats.\nUse it with /rename, or open it to change anything."
+    kind = fmt.get("kind", "manual")
+    use = "Use it with /rename" if kind == "manual" else "Choose it in the /start menu to rename your files with it"
+    text = f"✅ <b>{esc(clip(fmt['name'], 30))}</b> is now in your {kind} formats.\n{use}, or open it to change anything."
     return text, [[("🗂 Open format", f"fm:v:{fmt['id']}")], [("✖ Close", "x:close")]]
 
 
@@ -368,14 +481,16 @@ def format_delete_confirm(fmt: Dict[str, Any]) -> Panel:
 
 
 def rename_picker(formats: Sequence[Dict[str, Any]]) -> Panel:
+    """/rename: the manual formats (an auto format is chosen in the /start menu)."""
     if not formats:
         text = (
-            "<b>🏷 RENAME</b>\n\nYou have no saved formats yet.\n"
-            "A format keeps a template, caption, thumbnail and metadata under a name, like <i>One Piece</i>. Create one, then come back here."
+            "<b>🏷 MANUAL RENAME</b>\n\nYou have no manual formats yet.\n"
+            "A format keeps a template, caption, thumbnail and metadata under a name, like <i>One Piece</i>. Create one, then come back here.\n"
+            "Files you just send me are renamed with your auto format."
         )
-        return text, [[("➕ Create a format", "fm:new")], [("✖ Close", "x:close")]]
-    text = "<b>🏷 RENAME</b>\n\nChoose the format to rename with. I'll ask for your files next."
-    rows = _format_buttons(formats, "rn:p") + [[("⚙️ Manage formats", "m:formats"), ("✖ Close", "x:close")]]
+        return text, [[("➕ Create a format", "fm:new:manual")], [("✖ Close", "x:close")]]
+    text = "<b>🏷 MANUAL RENAME</b>\n\nChoose the manual format to rename with. I'll ask for your file next."
+    rows = _format_buttons(formats, "rn:p") + [[("⚙️ Manage formats", "fm:l:manual"), ("✖ Close", "x:close")]]
     return text, rows
 
 
@@ -505,6 +620,7 @@ 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>"
@@ -563,9 +679,9 @@ FORMAT_PROMPTS: Dict[str, str] = {
 }
 
 
-def format_prompt(field: str, fid: int) -> Panel:
-    """The "send me the value" screen for one field of a format (``fid`` 0 = a format that is being created)."""
-    cancel = f"fm:cx:{fid}" if fid else "m:formats"
+def format_prompt(field: str, fid: int, kind: str = "") -> Panel:
+    """The "send me the value" screen for one field of a format (``fid`` 0 = a format of ``kind`` that is being created)."""
+    cancel = f"fm:cx:{fid}" if fid else (f"fm:l:{kind}" if kind else "m:formats")
     return FORMAT_PROMPTS[field], [[("✖ Cancel", cancel)]]
 
 

bot/parser.py

@@ -10,7 +10,9 @@ from dataclasses import dataclass
 from typing import Dict, Iterable, List, Optional, Tuple
 
 DEFAULT_TEMPLATE = "[S{season}E{episode}] {title} [{quality}]"
-TEMPLATE_VARS = ("title", "season", "episode", "quality", "year", "codec", "filename", "ext")
+# {1episode} ... {3episode}: the episode with zeros in front until it is 2 ... 4 digits wide (4 -> 04 / 004 / 0004)
+PADDED_EPISODE_VARS = tuple(f"{zeros}episode" for zeros in range(1, 4))
+TEMPLATE_VARS = ("title", "season", "episode", *PADDED_EPISODE_VARS, "quality", "year", "codec", "filename", "ext")
 MAX_NAME_BYTES = 200
 
 KNOWN_EXTS = {
@@ -143,6 +145,13 @@ def _fmt_num(value: str) -> str:
     return f"{int(value):02d}"
 
 
+def padded_episode(episode: str, zeros: int) -> str:
+    """``episode`` with zeros in front until it is ``zeros + 1`` digits wide: with 2 zeros, ``4``, ``04`` and ``004`` all give
+    ``004``.  A number that is already that wide stays exactly as it is (``1147`` with 2 zeros is ``1147``); no episode gives
+    no text.  (``parse_info`` hands over the episode as at least two digits, without zeros it does not need: ``E004`` is ``04``.)"""
+    return episode.zfill(zeros + 1) if episode.isdigit() else episode
+
+
 def _is_year(value: str) -> bool:
     return 1900 <= int(value) <= 2099
 
@@ -382,7 +391,8 @@ def missing_variables(template: str, info: Info) -> List[str]:
     """
     out: List[str] = []
     for name in _TOKEN_RE.findall(_GROUP_RE.sub("", template or "")):
-        if name in ("season", "episode", "quality", "year", "codec") and not getattr(info, name) and name not in out:
+        field = "episode" if name in PADDED_EPISODE_VARS else name  # {2episode} is empty exactly when {episode} is
+        if field in ("season", "episode", "quality", "year", "codec") and not getattr(info, field) and name not in out:
             out.append(name)
     return out
 
@@ -407,6 +417,7 @@ def build_values(info: Info, original_stem: str, ext: str) -> Dict[str, str]:
         "title": info.title or _clean_title(original_stem),
         "season": info.season,
         "episode": info.episode,
+        **{name: padded_episode(info.episode, zeros) for zeros, name in enumerate(PADDED_EPISODE_VARS, 1)},
         "quality": info.quality,
         "year": info.year,
         "codec": info.codec,
@@ -447,7 +458,9 @@ def compute_new_name(
 # captions
 # ---------------------------------------------------------------------------
 
-CAPTION_VARS = ("filename", "original", "title", "season", "episode", "quality", "year", "codec", "ext", "size", "duration")
+CAPTION_VARS = (
+    "filename", "original", "title", "season", "episode", *PADDED_EPISODE_VARS, "quality", "year", "codec", "ext", "size", "duration"
+)
 
 
 def render_caption(template: str, values: Dict[str, str]) -> str:

bot/pipeline.py

@@ -129,9 +129,7 @@ class Renamer:
 
     # ------------------------------------------------------------------
     async def process(self, job: Job) -> None:
-        s = await self.db.get_settings(job.user_id)
-        if job.fmt:
-            s = apply_format(s, job.fmt)
+        s = apply_format(await self.db.get_settings(job.user_id), job.fmt)  # no format: the built-in template and caption
         work = Path(self.cfg.temp_dir) / f"job{job.id}"
         work.mkdir(parents=True, exist_ok=True)
         reporter = ProgressReporter(self.client, job.status_msg, job.id, job.new_name, self.cfg.progress_interval)
@@ -154,11 +152,8 @@ class Renamer:
             shutil.rmtree(work, ignore_errors=True)
 
     async def _custom_thumb(self, job: Job) -> Optional[bytes]:
-        """The thumbnail the user chose: the one of the format being used, else their default one."""
-        thumb = await self.db.get_format_thumb(job.user_id, job.fmt["id"]) if job.fmt else None
-        if thumb is None:
-            thumb = await self.db.get_thumb(job.user_id)
-        return thumb
+        """The thumbnail the user chose: the one of the format being used (``None``: a frame of the video is used)."""
+        return await self.db.get_format_thumb(job.user_id, job.fmt["id"]) if job.fmt else None
 
     async def _stream_plan(
         self, job: Job, s: Dict[str, Any], msg: Any, ext: str, send_type: str, size: int

bot/queue.py

@@ -20,7 +20,7 @@ class Job:
     file_name: str
     size: int
     new_name: str
-    fmt: Optional[Dict[str, Any]] = None  # the saved /rename format this job uses (a snapshot taken when it was queued)
+    fmt: Optional[Dict[str, Any]] = None  # the saved format (auto or manual) this job uses, a snapshot taken when it was queued; None: no auto format
     notes: List[str] = field(default_factory=list)  # warnings shown with the queued / finished message
     order: int = 0  # id of the message that triggered the job: files are processed oldest message first
     status_msg: Any = None

bot/settings_ops.py

@@ -2,16 +2,20 @@
 
 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).
 """
 from __future__ import annotations
 
 import re
 from typing import Optional, Tuple
 
-from .db import DEFAULT_SETTINGS, Database
+from .db import DEFAULT_CAPTION, Database
 from .media import parse_track_tokens, validate_track_tokens
 from .parser import (
     CAPTION_VARS,
+    DEFAULT_TEMPLATE,
     TEMPLATE_VARS,
     finalize_name,
     render_template,
@@ -50,7 +54,7 @@ async def apply_setting(db: Database, uid: int, kind: str, text: str) -> Tuple[b
         if not text:
             return False, "❌ The template can't be empty."
         if _is_clear(text):
-            text = DEFAULT_SETTINGS["template"]
+            text = DEFAULT_TEMPLATE
         if len(text) > 200:
             return False, "❌ That template is too long (200 characters max)."
         unknown = sorted(set(_TOKEN_RE.findall(text)) - set(TEMPLATE_VARS))
@@ -64,7 +68,7 @@ async def apply_setting(db: Database, uid: int, kind: str, text: str) -> Tuple[b
         if not text:
             return False, "❌ The caption can't be empty. Send <code>reset</code> to restore the default."
         if _is_clear(text):
-            text = DEFAULT_SETTINGS["caption"]
+            text = DEFAULT_CAPTION
         if len(text) > 800:
             return False, "❌ That caption is too long (800 characters max, formatting and link addresses included)."
         unknown = sorted(set(_TOKEN_RE.findall(text)) - set(CAPTION_VARS))

tests/appkit.py

@@ -68,6 +68,24 @@ async def prefs(ctx, uid=OWNER):
     return await ctx.db.get_settings(uid)
 
 
+async def autofmt(ctx, uid=OWNER):
+    """The auto format that renames the user's files (``None`` when they have none)."""
+    return await ctx.db.get_auto_format(uid)
+
+
+async def auto_thumb(ctx, uid=OWNER):
+    """The thumbnail of the user's auto format (``None`` when there is none)."""
+    fmt = await autofmt(ctx, uid)
+    return await ctx.db.get_format_thumb(uid, fmt["id"]) if fmt is not None and fmt["has_thumb"] else None
+
+
+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)
+    await ctx.db.set_format_thumb(uid, fmt["id"], data)
+    return fmt
+
+
 def jpeg(size=(640, 480)):
     buf = io.BytesIO()
     Image.new("RGB", size, (200, 30, 30)).save(buf, "JPEG")

tests/test_app.py

@@ -15,7 +15,10 @@ from bot.db import Database
 from bot.queue import JobQueue
 
 from .conftest import needs_ffmpeg
-from .appkit import ADMIN_CFG, ADMIN_DB, EPISODE, EPISODE_NEW, LOG, OWNER, STRANGER, click, data_of, env_for, jpeg, prefs, say, send_doc
+from .appkit import (
+    ADMIN_CFG, ADMIN_DB, EPISODE, EPISODE_NEW, LOG, OWNER, STRANGER, auto_thumb, autofmt, click, data_of, env_for, jpeg, prefs, say,
+    send_doc, set_auto_thumb,
+)
 from .tgfakes import (
     FakeCallback, FakeClient, FakeEvent, FakeMessage, dispatch, document_message, flat_buttons, make_file, variables_line,
 )
@@ -115,7 +118,7 @@ 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:rename", "m:cap", "m:meta", "m:ftype", "m:help", "m:admin"} <= set(data_of(buttons))
+    assert {"m:auto", "m:rename", "m:cap", "m:meta", "m:ftype", "m:formats", "m:help", "m:admin"} <= set(data_of(buttons))
     assert "m:admin" not in data_of((await say(ctx, ADMIN_CFG, "/start")).out[0][1])
 
 
@@ -164,14 +167,23 @@ async def test_metadata_command(ctx):
 
 
 async def test_template_caption_and_removewords_commands(ctx):
+    assert await autofmt(ctx) is None
+    assert "Template of your auto format" in (await say(ctx, OWNER, "/template")).texts[0]
+    assert await autofmt(ctx) is None  # only looking: no format is made
+
     ev = await say(ctx, OWNER, "/template [S{season}E{episode}] {title} [{quality}]")
     assert "Template saved" in ev.texts[0]
-    assert (await prefs(ctx))["template"] == "[S{season}E{episode}] {title} [{quality}]"
-    assert "Current template" in (await say(ctx, OWNER, "/template")).texts[0]
+    auto = await autofmt(ctx)  # they are the template and caption 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 "template" not in await prefs(ctx) and "caption" not in await prefs(ctx)
+    text = (await say(ctx, OWNER, "/template")).texts[0]
+    assert "Template of your auto format" in text and "[S{season}E{episode}] {title} [{quality}]" in text
 
     await say(ctx, OWNER, "/caption <b>{filename}</b> {size}")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b> {size}"
-    assert "Current caption template" in (await say(ctx, OWNER, "/caption")).texts[0]
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b> {size}"
+    assert "Caption of your auto format" in (await say(ctx, OWNER, "/caption")).texts[0]
+    assert await ctx.db.count_formats(OWNER) == 1  # both went into the same format
 
     await say(ctx, OWNER, "/removewords @Chan, [Group]")
     assert (await prefs(ctx))["remove_words"] == ["@Chan", "[Group]"]
@@ -182,9 +194,9 @@ async def test_template_caption_and_removewords_commands(ctx):
 
 async def test_template_and_caption_commands_list_each_variable_as_its_own_copyable_block(ctx):
     line, blocks = variables_line((await say(ctx, OWNER, "/template")).texts[0])
-    assert blocks == line.split(": ", 1)[1].split() and "{quality}" in blocks and len(blocks) == 8
+    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 say(ctx, OWNER, "/caption")).texts[0])
-    assert blocks == line.split(": ", 1)[1].split() and "{size}" in blocks and len(blocks) == 10
+    assert blocks == line.split(": ", 1)[1].split() and "{size}" in blocks and "{3episode}" in blocks and "{4episode}" not in blocks and len(blocks) == 13
 
 
 async def test_settings_are_per_user(ctx):
@@ -247,24 +259,48 @@ async def test_setchannel(ctx):
 # ---------------------------------------------------------------------------
 
 
-async def test_photo_becomes_the_thumbnail_and_can_be_viewed_and_deleted(ctx):
+async def test_photo_becomes_the_thumbnail_of_the_auto_format_and_can_be_viewed_and_deleted(ctx):
+    assert "no thumbnail" in (await say(ctx, OWNER, "/thumb")).texts[0] and await autofmt(ctx) is None
     ev = FakeEvent(OWNER, message=FakeMessage("", mid=20, photo=True), photo_bytes=jpeg())
     await dispatch(ctx.client, ev)
-    assert "Thumbnail saved" in ev.texts[0] and "th:rm" in data_of(ev.out[0][1])
-    stored = await ctx.db.get_thumb(OWNER)
+    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 /template 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 ctx.db.get_thumb(ADMIN_CFG) is None  # per user
+    assert await auto_thumb(ctx, ADMIN_CFG) is None and await autofmt(ctx, ADMIN_CFG) is None  # per user
 
     await say(ctx, OWNER, "/thumb")
     (chat, file, kw), = ctx.client.files
-    assert chat == OWNER and file.read() == stored and "th:rm" in data_of(kw["buttons"])
+    assert chat == OWNER and file.read() == stored and f"th:rm:{auto['id']}" in data_of(kw["buttons"])
 
     assert "deleted" in (await say(ctx, OWNER, "/delthumb")).texts[0]
-    assert await ctx.db.get_thumb(OWNER) is None
+    assert await auto_thumb(ctx) is None and (await autofmt(ctx))["id"] == auto["id"]  # the format stays
     assert "no thumbnail" in (await say(ctx, OWNER, "/delthumb")).texts[0]
     assert "no thumbnail" in (await say(ctx, OWNER, "/thumb")).texts[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
+
+
+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_unreadable_photos_are_reported(ctx):
     ev = FakeEvent(OWNER, message=FakeMessage("", photo=True), photo_bytes=b"not an image")
     await dispatch(ctx.client, ev)
@@ -272,26 +308,75 @@ async def test_unreadable_photos_are_reported(ctx):
     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 ctx.db.get_thumb(OWNER) is None
+    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)
-    assert stranger.out == [] and await ctx.db.get_thumb(STRANGER) is None
+    assert stranger.out == [] and await autofmt(ctx, STRANGER) is None
 
 
-async def test_thumbnail_buttons(ctx):
+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 ctx.db.set_thumb(OWNER, b"\xff\xd8thumb")
+    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 ctx.db.get_thumb(OWNER) is None and "CAPTION" in cb.edits[-1][0] and "none" in cb.edits[-1][0]
+    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 ctx.db.set_thumb(OWNER, b"\xff\xd8thumb")
+    await set_auto_thumb(ctx, b"\xff\xd8thumb")
     cb = await click(ctx, OWNER, "th:rm")  # under a standalone thumbnail message
-    assert await ctx.db.get_thumb(OWNER) is None and cb.deleted and cb.edits == []
+    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 say(ctx, OWNER, "/thumb")  # the Delete button under it 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"
 
 
 # ---------------------------------------------------------------------------
@@ -650,8 +735,9 @@ async def test_toggles_update_settings_and_refresh_the_panel(ctx):
 
 async def test_clear_buttons(ctx):
     await say(ctx, OWNER, "/caption custom {filename}")
+    assert (await autofmt(ctx))["caption"] == "custom {filename}"
     cb = await click(ctx, OWNER, "clr:caption")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b>" and "CAPTION" in cb.edits[-1][0]
+    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")
@@ -695,7 +781,9 @@ async def test_admin_panel_buttons(ctx):
 
 @pytest.mark.parametrize("panel", sorted(PANEL_NAMES))
 async def test_every_button_of_every_panel_is_handled(ctx, panel):
-    await ctx.db.set_thumb(OWNER, b"\xff\xd8thumb")
+    await set_auto_thumb(ctx, b"\xff\xd8thumb")
+    await ctx.db.create_format(OWNER, "Other auto", kind="auto")
+    await ctx.db.create_format(OWNER, "Manual one", kind="manual")
     _text, rows = await ctx.app.panel(OWNER, panel)
     clicked = 0
     for row in rows:
@@ -727,7 +815,7 @@ 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)
     assert ev.deleted and OWNER not in ctx.app.pending  # the typed value is removed to keep the chat tidy
-    assert (await prefs(ctx))["template"] == "{title} [{quality}]"
+    assert (await autofmt(ctx))["template"] == "{title} [{quality}]"
     (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"])
@@ -748,7 +836,7 @@ async def test_invalid_input_keeps_the_prompt_open(ctx):
     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 prefs(ctx))["template"] == "{title}"
+    assert OWNER not in ctx.app.pending and (await autofmt(ctx))["template"] == "{title}"
 
 
 async def test_expired_prompts_and_other_users_text_are_ignored(ctx):
@@ -758,7 +846,7 @@ async def test_expired_prompts_and_other_users_text_are_ignored(ctx):
     ctx.app.pending[OWNER].expires = time.time() - 1
     ev = await say(ctx, OWNER, "{title}")
     assert ev.out == [] and not ev.deleted and OWNER not in ctx.app.pending
-    assert (await prefs(ctx))["template"] != "{title}"
+    assert await autofmt(ctx) is None  # nothing was saved
 
 
 async def test_plain_text_without_a_prompt_is_ignored(ctx):

tests/test_auto_formats_app.py

@@ -0,0 +1,319 @@
+"""Auto formats in the app: the /start menu's Auto Format screen, Use for auto rename, copying a format to the other kind,
+Apply default metadata, and what the files are renamed with."""
+import pytest
+
+from bot.db import MAX_FORMATS
+from bot.formats import apply_format
+
+from .appkit import ADMIN_CFG, EPISODE_NEW, OWNER, autofmt, click, data_of, jpeg, prefs, say, send_doc
+from .test_formats_app import ONE_PIECE, labels_of, make_format
+
+DEFAULT_META = {"title": "My Channel", "author": "@MyChannel", "artist": "", "audio": "{lang} Audio", "subtitle": "{lang}", "video": "HD"}
+
+
+async def set_default_metadata(ctx, **over):
+    await ctx.db.update_settings(OWNER, meta=dict(DEFAULT_META), keep_audio=["japanese", "english"], keep_subtitle=["english"], **over)
+
+
+def latest_job(ctx):
+    return list(ctx.app.queue.jobs.values())[-1]
+
+
+# ---------------------------------------------------------------------------
+# the Auto Format screen of the /start menu
+# ---------------------------------------------------------------------------
+
+
+async def test_the_start_menu_opens_the_auto_format_screen(ctx):
+    ev = await say(ctx, OWNER, "/start")
+    text, buttons, _kw = ev.out[0]
+    assert "<b>Auto format:</b> none saved" in text and "m:auto" in data_of(buttons) and "Auto Format" in labels_of(buttons)
+    cb = await click(ctx, OWNER, "m:auto")
+    text, buttons = cb.edits[-1]
+    assert "AUTO RENAME FORMAT" in text and "no auto formats yet" in text and cb.answers
+    data = data_of(buttons)
+    assert {"fm:new:auto", "fm:l:auto", "m:home", "x:close"} <= set(data) and not any(d.startswith("au:") for d in data)
+
+
+async def test_the_screen_lists_the_auto_formats_and_marks_the_one_in_use(ctx):
+    a = await make_format(ctx, "One Piece", kind="auto", template="OP - E{episode}")
+    b = await make_format(ctx, "Dragon Ball", kind="auto", template="DB - E{episode}")
+    manual = await make_format(ctx, "Manual one")
+    cb = await click(ctx, OWNER, "m:auto")
+    text, buttons = cb.edits[-1]
+    data = data_of(buttons)
+    assert f"au:{a['id']}" in data and f"au:{b['id']}" in data and f"au:{manual['id']}" not in data
+    assert labels_of(buttons)[:2] == ["One Piece ✅", "Dragon Ball"]  # the first one is in use from the start
+    assert f"fm:v:{a['id']}" in data  # "Edit the one in use"
+
+    cb = await click(ctx, OWNER, f"au:{b['id']}")
+    assert cb.toasts == ["Auto format: Dragon Ball"] and labels_of(cb.edits[-1][1])[:2] == ["One Piece", "Dragon Ball ✅"]
+    assert (await prefs(ctx))["auto_format"] == b["id"] and (await autofmt(ctx))["id"] == b["id"]
+    data = data_of(cb.edits[-1][1])
+    assert f"fm:v:{b['id']}" in data and f"fm:v:{a['id']}" not in data  # the edit button follows the choice
+
+    ev = await say(ctx, OWNER, "/start")  # and the menu shows what is in use
+    assert "<b>Auto format:</b> <b>Dragon Ball</b>" in ev.texts[0] and "DB - E{episode}" in ev.texts[0]
+
+
+async def test_a_stale_or_foreign_choice_is_refused(ctx):
+    manual = await make_format(ctx, "Manual one")
+    theirs = await make_format(ctx, "Theirs", uid=ADMIN_CFG, kind="auto")
+    await make_format(ctx, "Mine", kind="auto")
+    for data in (f"au:{manual['id']}", f"au:{theirs['id']}", "au:999999", "au:x", "au"):
+        cb = await click(ctx, OWNER, data)
+        assert cb.alerts == ["That format no longer exists."] and "AUTO RENAME FORMAT" in cb.edits[-1][0], data
+        assert (await autofmt(ctx))["name"] == "Mine"
+
+
+async def test_each_user_has_their_own_auto_format(ctx):
+    mine = await make_format(ctx, "Mine", kind="auto", template="Mine - {title}")
+    theirs = await make_format(ctx, "Theirs", uid=ADMIN_CFG, kind="auto", template="Theirs - {title}")
+    await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
+    await send_doc(ctx, ADMIN_CFG, ONE_PIECE, mid=51)
+    jobs = {j.user_id: j for j in ctx.app.queue.jobs.values()}
+    assert jobs[OWNER].new_name == "Mine - One Piece.mkv" and jobs[OWNER].fmt["id"] == mine["id"]
+    assert jobs[ADMIN_CFG].new_name == "Theirs - One Piece.mkv" and jobs[ADMIN_CFG].fmt["id"] == theirs["id"]
+
+
+# ---------------------------------------------------------------------------
+# what the files are renamed with
+# ---------------------------------------------------------------------------
+
+
+async def test_the_auto_format_in_use_renames_every_file_sent(ctx):
+    a = await make_format(ctx, "One Piece", kind="auto", template="OP - E{episode}")
+    b = await make_format(ctx, "Dragon Ball", kind="auto", template="DB - E{episode}")
+    ev = await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
+    job = latest_job(ctx)
+    assert job.new_name == "OP - E1147.mkv" and job.fmt["id"] == a["id"] and job.fmt["kind"] == "auto"
+    assert "🗂 Auto format: <b>One Piece</b>" in ev.texts[0]
+    await click(ctx, OWNER, f"au:{b['id']}")
+    ev = await send_doc(ctx, OWNER, ONE_PIECE, mid=51)
+    job = latest_job(ctx)
+    assert job.new_name == "DB - E1147.mkv" and job.fmt["id"] == b["id"] and "🗂 Auto format: <b>Dragon Ball</b>" in ev.texts[0]
+
+
+async def test_without_an_auto_format_files_get_the_built_in_template(ctx):
+    await make_format(ctx, "Manual one")  # a manual format is never used by itself
+    ev = await send_doc(ctx, OWNER)
+    (job,) = ctx.app.queue.jobs.values()
+    assert job.fmt is None and job.new_name == EPISODE_NEW and "Auto format" not in ev.texts[0]
+
+
+async def test_the_padded_episode_variables_in_an_auto_format(ctx):
+    await make_format(ctx, "Padded", kind="auto", template="{title} - {1episode} {2episode} {3episode}")
+    for mid, name, expected in (
+        (50, "One Piece - 4 [1080p].mkv", "One Piece - 04 004 0004.mkv"),
+        (51, "One Piece - 321 [1080p].mkv", "One Piece - 321 321 0321.mkv"),
+        (52, "One Piece - 1321 [1080p].mkv", "One Piece - 1321 1321 1321.mkv"),
+    ):
+        await send_doc(ctx, OWNER, name, mid=mid)
+        assert latest_job(ctx).new_name == expected
+
+
+async def test_the_first_auto_format_is_used_at_once_and_deleting_the_one_in_use_hands_over(ctx):
+    await click(ctx, OWNER, "fm:new:auto", msg_id=500)
+    await say(ctx, OWNER, "One Piece")
+    (a,) = await ctx.db.list_formats(OWNER, "auto")
+    _chat, text, kw = ctx.client.edited[-1]
+    assert "✅ In use" in text and f"fm:use:{a['id']}" not in data_of(kw["buttons"])
+    assert (await autofmt(ctx))["id"] == a["id"]
+    await make_format(ctx, "Dragon Ball", kind="auto")
+
+    await click(ctx, OWNER, f"fm:del:{a['id']}")
+    cb = await click(ctx, OWNER, f"fm:ok:{a['id']}")  # the one in use goes: the other takes over
+    assert "AUTO FORMATS" in cb.edits[-1][0] and "Dragon Ball ✅" in labels_of(cb.edits[-1][1])
+    last = await autofmt(ctx)
+    assert last["name"] == "Dragon Ball"
+    await click(ctx, OWNER, f"fm:ok:{last['id']}")  # the last one goes: back to the built-in defaults
+    assert await autofmt(ctx) is None
+    await send_doc(ctx, OWNER)
+    (job,) = ctx.app.queue.jobs.values()
+    assert job.fmt is None and job.new_name == EPISODE_NEW
+
+
+async def test_use_for_auto_rename_button(ctx):
+    a = await make_format(ctx, "One Piece", kind="auto")
+    b = await make_format(ctx, "Dragon Ball", kind="auto")
+    cb = await click(ctx, OWNER, f"fm:v:{a['id']}")
+    assert "✅ In use" in cb.edits[-1][0] and f"fm:use:{a['id']}" not in data_of(cb.edits[-1][1])
+    cb = await click(ctx, OWNER, f"fm:v:{b['id']}")
+    text, buttons = cb.edits[-1]
+    assert "Not in use" in text and f"fm:use:{b['id']}" in data_of(buttons) and "✅ Use for auto rename" in labels_of(buttons)
+
+    cb = await click(ctx, OWNER, f"fm:use:{b['id']}")
+    text, buttons = cb.edits[-1]
+    assert cb.toasts == ["Auto format: Dragon Ball"] and "now renames your files" in text and "✅ In use" in text
+    assert f"fm:use:{b['id']}" not in data_of(buttons) and (await autofmt(ctx))["id"] == b["id"]
+    cb = await click(ctx, OWNER, f"fm:v:{a['id']}")  # the other one can be used again
+    assert f"fm:use:{a['id']}" in data_of(cb.edits[-1][1])
+
+
+async def test_a_manual_format_cannot_be_used_for_auto_rename(ctx):
+    auto = await make_format(ctx, "Auto one", kind="auto")
+    manual = await make_format(ctx, "Manual one")
+    cb = await click(ctx, OWNER, f"fm:v:{manual['id']}")
+    assert f"fm:use:{manual['id']}" not in data_of(cb.edits[-1][1]) and "Use it with /rename" in cb.edits[-1][0]
+    cb = await click(ctx, OWNER, f"fm:use:{manual['id']}")  # a stale button
+    assert cb.alerts == ["Only an auto format can be used for auto rename."] and cb.edits == []
+    assert (await autofmt(ctx))["id"] == auto["id"]
+
+
+# ---------------------------------------------------------------------------
+# copying a format to the other kind
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("source, target", [("auto", "manual"), ("manual", "auto")])
+async def test_a_format_can_be_copied_to_the_other_kind(ctx, source, target):
+    fmt = await make_format(ctx, "One Piece", kind=source, meta={"title": "OP"}, keep_audio=["japanese"], caption="<i>{filename}</i>")
+    await ctx.db.set_format_thumb(OWNER, fmt["id"], jpeg())
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert f"fm:cp:{fmt['id']}" in data_of(cb.edits[-1][1]) and f"📋 Copy to {target} formats" in labels_of(cb.edits[-1][1])
+
+    cb = await click(ctx, OWNER, f"fm:cp:{fmt['id']}")
+    (copy,) = await ctx.db.list_formats(OWNER, target)
+    assert copy["id"] != fmt["id"] and copy["kind"] == target and copy["name"] == "One Piece"
+    assert copy["template"] == "One Piece - E{episode}" and copy["meta"]["title"] == "OP" and copy["keep_audio"] == ["japanese"]
+    assert copy["caption"] == "<i>{filename}</i>" and await ctx.db.get_format_thumb(OWNER, copy["id"]) == jpeg()
+    text, buttons = cb.edits[-1]
+    assert cb.toasts == [f"Copied to your {target} formats."] and f"is copied to your {target} formats" in text
+    assert data_of(buttons) == [f"fm:v:{copy['id']}", f"fm:v:{fmt['id']}", "x:close"]
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["kind"] == source and await ctx.db.count_formats(OWNER, source) == 1
+
+    cb = await click(ctx, OWNER, f"fm:v:{copy['id']}")  # "Open the copy": it is a format of the other kind
+    assert f"{'🤖 Auto' if target == 'auto' else '✋ Manual'}" in cb.edits[-1][0].splitlines()[0]
+
+
+async def test_copies_are_independent_and_get_a_free_name(ctx):
+    fmt = await make_format(ctx, "One Piece", kind="auto")
+    await click(ctx, OWNER, f"fm:cp:{fmt['id']}")
+    await click(ctx, OWNER, f"fm:cp:{fmt['id']}")
+    first, second = await ctx.db.list_formats(OWNER, "manual")
+    assert [first["name"], second["name"]] == ["One Piece", "One Piece (2)"]
+    await click(ctx, OWNER, f"fm:cp:{first['id']}")  # and back again: "One Piece" is taken among the auto formats
+    back = (await ctx.db.list_formats(OWNER, "auto"))[-1]
+    assert back["name"] == "One Piece (2)" and back["kind"] == "auto" and await ctx.db.count_formats(OWNER, "auto") == 2
+
+    await click(ctx, OWNER, f"fm:in:{first['id']}:template")
+    await say(ctx, OWNER, "Changed {title}")
+    assert (await ctx.db.get_format(OWNER, first["id"]))["template"] == "Changed {title}"
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["template"] == "One Piece - E{episode}"
+    assert (await ctx.db.get_format(OWNER, second["id"]))["template"] == "One Piece - E{episode}"
+
+
+@pytest.mark.parametrize("kind", ["auto", "manual"])
+async def test_copying_to_a_full_kind_is_refused_and_the_kinds_count_apart(ctx, kind):
+    other = "manual" if kind == "auto" else "auto"
+    fmt = await make_format(ctx, "One Piece", kind=kind)
+    for i in range(MAX_FORMATS):
+        await make_format(ctx, f"F{i}", kind=other)
+    cb = await click(ctx, OWNER, f"fm:cp:{fmt['id']}")
+    assert cb.alerts == [f"You already have {MAX_FORMATS} {other} formats. Delete one first."] and cb.edits == []
+    assert await ctx.db.count_formats(OWNER, other) == MAX_FORMATS and await ctx.db.count_formats(OWNER, kind) == 1
+
+
+async def test_a_copy_shows_up_where_its_kind_is_used(ctx):
+    auto = await make_format(ctx, "From auto", kind="auto")
+    manual = await make_format(ctx, "From manual")
+    await click(ctx, OWNER, f"fm:cp:{auto['id']}")  # a manual copy of the auto format
+    await click(ctx, OWNER, f"fm:cp:{manual['id']}")  # an auto copy of the manual one
+    assert {"From manual", "From auto"} <= set(labels_of((await say(ctx, OWNER, "/rename")).out[0][1]))
+    labels = labels_of((await click(ctx, OWNER, "m:auto")).edits[-1][1])
+    assert "From auto ✅" in labels and "From manual" in labels
+
+
+async def test_an_auto_format_made_by_copying_is_the_first_one_and_renames_the_files(ctx):
+    manual = await make_format(ctx, "One Piece")
+    assert await autofmt(ctx) is None
+    await click(ctx, OWNER, f"fm:cp:{manual['id']}")
+    auto = await autofmt(ctx)
+    assert auto["kind"] == "auto" and auto["name"] == "One Piece"
+    ev = await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
+    assert "🗂 Auto format: <b>One Piece</b>" in ev.texts[0] and latest_job(ctx).new_name == "One Piece - E1147.mkv"
+
+
+# ---------------------------------------------------------------------------
+# Apply default metadata
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("kind", ["auto", "manual"])
+async def test_apply_default_metadata_copies_all_of_it_into_the_format(ctx, kind):
+    await set_default_metadata(ctx)  # the metadata switch is Off: copying does not depend on it
+    fmt = await make_format(
+        ctx, "One Piece", kind=kind, meta={"title": "Old title", "artist": "Old artist"}, keep_audio=["french"], keep_subtitle=["2"]
+    )
+    cb = await click(ctx, OWNER, f"fm:dm:{fmt['id']}")
+    got = await ctx.db.get_format(OWNER, fmt["id"])
+    assert got["meta"] == DEFAULT_META and got["keep_audio"] == ["japanese", "english"] and got["keep_subtitle"] == ["english"]
+    assert got["template"] == "One Piece - E{episode}" and got["kind"] == kind  # nothing else changed
+    text, buttons = cb.edits[-1]
+    assert cb.toasts == ["Default metadata applied."] and "Your default metadata is now in <b>One Piece</b>" in text
+    assert "<b>Title</b> ▸ <code>My Channel</code>" in text and "Japanese, English" in text and f"fm:dm:{fmt['id']}" in data_of(buttons)
+
+    s = await prefs(ctx)  # the default metadata itself is untouched, and the format is not linked to it afterwards
+    assert s["meta"] == DEFAULT_META and s["keep_audio"] == ["japanese", "english"] and s["metadata_on"] is False
+    await ctx.db.update_settings(OWNER, meta={"title": "Changed later"})
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["meta"]["title"] == "My Channel"
+
+
+@pytest.mark.parametrize("kind", ["auto", "manual"])
+async def test_a_new_format_can_take_the_default_metadata_straight_away(ctx, kind):
+    await set_default_metadata(ctx)
+    await click(ctx, OWNER, f"fm:new:{kind}", msg_id=500)
+    await say(ctx, OWNER, "Fresh")
+    (fmt,) = await ctx.db.list_formats(OWNER)
+    _chat, text, kw = ctx.client.edited[-1]
+    assert "🏷 Apply default metadata" in labels_of(kw["buttons"]) and "Apply default metadata" in text
+    assert fmt["meta"]["title"] == ""
+    await click(ctx, OWNER, f"fm:dm:{fmt['id']}")
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["meta"] == DEFAULT_META
+
+
+@pytest.mark.parametrize("kind", ["auto", "manual"])
+async def test_apply_default_metadata_says_so_when_there_is_none(ctx, kind):
+    fmt = await make_format(ctx, "One Piece", kind=kind, meta={"title": "Mine"})
+    await ctx.db.update_settings(OWNER, metadata_on=True)  # the switch alone is not metadata
+    cb = await click(ctx, OWNER, f"fm:dm:{fmt['id']}")
+    assert cb.alerts == ["Your default metadata is empty. Set it in /metadata first, then apply it."] and cb.edits == []
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["meta"]["title"] == "Mine"  # nothing was wiped
+
+
+async def test_track_lists_alone_count_as_default_metadata(ctx):
+    await ctx.db.update_settings(OWNER, keep_audio=["english"])
+    fmt = await make_format(ctx, kind="auto")
+    cb = await click(ctx, OWNER, f"fm:dm:{fmt['id']}")
+    assert cb.toasts == ["Default metadata applied."] and (await ctx.db.get_format(OWNER, fmt["id"]))["keep_audio"] == ["english"]
+
+
+async def test_a_file_renamed_with_a_format_that_took_the_default_metadata_gets_it(ctx):
+    await set_default_metadata(ctx)
+    fmt = await make_format(ctx)
+    await click(ctx, OWNER, f"fm:dm:{fmt['id']}")
+    await click(ctx, OWNER, f"rn:p:{fmt['id']}")
+    await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
+    job = latest_job(ctx)
+    assert job.fmt["meta"]["title"] == "My Channel" and job.fmt["keep_audio"] == ["japanese", "english"]
+    out = apply_format(await prefs(ctx), job.fmt)
+    assert out["metadata_on"] is True and out["meta"]["video"] == "HD"  # written, although the default switch is Off
+
+
+async def test_an_auto_format_says_whether_the_default_metadata_applies_to_it(ctx):
+    auto = await make_format(ctx, "Auto one", kind="auto")
+    manual = await make_format(ctx, "Manual one")
+    cb = await click(ctx, OWNER, f"fm:v:{auto['id']}")
+    assert "No metadata of its own: your default metadata is used while it is On" in cb.edits[-1][0]
+    assert "your default metadata is used" not in (await click(ctx, OWNER, f"fm:v:{manual['id']}")).edits[-1][0]  # a manual one never uses it
+    await ctx.db.update_format(OWNER, auto["id"], meta={"title": "Own"})
+    assert "your default metadata is used" not in (await click(ctx, OWNER, f"fm:v:{auto['id']}")).edits[-1][0]
+
+
+async def test_the_metadata_screen_calls_it_default_metadata_and_points_to_the_button(ctx):
+    cb = await click(ctx, OWNER, "m:meta")
+    text = cb.edits[-1][0]
+    assert "Your default metadata is currently: Off" in text and "Apply default metadata" in text and "global" not in text.lower()
+    await click(ctx, OWNER, "set:meta:on")
+    assert (await prefs(ctx))["metadata_on"] is True  # the On/Off switch and the /metadata commands are unchanged
+    assert "currently: On" in (await say(ctx, OWNER, "/metadata")).texts[0]

tests/test_caption_formatting_app.py

@@ -1,9 +1,11 @@
-"""A caption keeps the formatting it was sent with (bold, italic, links...): nobody has to type HTML."""
+"""A caption keeps the formatting it was sent with (bold, italic, links...): nobody has to type HTML.
+
+/caption and the Set Caption button edit the caption of the auto format in use, 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, click, data_of, prefs, say, say_formatted
+from .appkit import OWNER, autofmt, click, data_of, 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]"
@@ -17,71 +19,71 @@ STORED = '<b>Watch</b> {title} <i>episode {episode}</i> on <a href="https://t.me
 
 async def test_the_caption_command_keeps_the_formatting_that_was_applied(ctx):
     ev = await say_formatted(ctx, OWNER, "/caption " + FORMATTED)
-    assert (await prefs(ctx))["caption"] == STORED
+    assert (await autofmt(ctx))["caption"] == STORED
     assert "Caption template saved" in ev.texts[0] and "Unknown" not in ev.texts[0]
 
 
 async def test_the_caption_command_shows_the_caption_with_its_formatting(ctx):
     await say_formatted(ctx, OWNER, "/caption " + FORMATTED)
     text = (await say(ctx, OWNER, "/caption")).texts[0]
-    assert "Current caption template" in text and STORED in text  # shown as the person wrote it, not as tags to read
+    assert "Caption of your auto format" in text and 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
 
 
 async def test_the_command_may_carry_the_bot_name_extra_spaces_and_several_lines(ctx):
     await say_formatted(ctx, OWNER, "/caption@RenameBot    [b]{filename}[/b]\nsecond [i]line[/i] {size}")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b>\nsecond <i>line</i> {size}"
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>\nsecond <i>line</i> {size}"
 
 
 async def test_emoji_before_the_formatted_words_do_not_shift_it(ctx):
     await say_formatted(ctx, OWNER, "/caption 🔥🔥 [b]{filename}[/b] 👨‍👩‍👧 [i]{size}[/i]")
-    assert (await prefs(ctx))["caption"] == "🔥🔥 <b>{filename}</b> 👨‍👩‍👧 <i>{size}</i>"
+    assert (await autofmt(ctx))["caption"] == "🔥🔥 <b>{filename}</b> 👨‍👩‍👧 <i>{size}</i>"
 
 
 async def test_html_typed_by_hand_still_works_when_nothing_is_formatted(ctx):
     await say(ctx, OWNER, "/caption <i>{filename}</i> · <a href=\"https://t.me/x\">join</a>")
-    assert (await prefs(ctx))["caption"] == '<i>{filename}</i> · <a href="https://t.me/x">join</a>'
+    assert (await autofmt(ctx))["caption"] == '<i>{filename}</i> · <a href="https://t.me/x">join</a>'
 
 
 async def test_what_telegram_finds_by_itself_is_not_formatting(ctx):
     """A #hashtag or an @mention is an entity too, but nothing was formatted: typed tags are still taken as typed."""
     await say_formatted(ctx, OWNER, "/caption <i>{filename}</i> [tag]#anime[/tag] [at]@channel[/at]")
-    assert (await prefs(ctx))["caption"] == "<i>{filename}</i> #anime @channel"
+    assert (await autofmt(ctx))["caption"] == "<i>{filename}</i> #anime @channel"
 
 
 async def test_once_words_are_formatted_the_message_is_taken_as_written(ctx):
     await say_formatted(ctx, OWNER, "/caption <b>{filename}</b> [i]x[/i]")
-    assert (await prefs(ctx))["caption"] == "&lt;b&gt;{filename}&lt;/b&gt; <i>x</i>"  # the tags the person typed are just text
+    assert (await autofmt(ctx))["caption"] == "&lt;b&gt;{filename}&lt;/b&gt; <i>x</i>"  # the tags the person typed are just text
 
 
 async def test_a_spoiler_is_not_kept_so_its_words_stay_plain(ctx):
     await say_formatted(ctx, OWNER, "/caption [spoiler]secret[/spoiler] {title}")
-    assert (await prefs(ctx))["caption"] == "secret {title}"
+    assert (await autofmt(ctx))["caption"] == "secret {title}"
 
 
 async def test_reset_still_resets_when_it_was_made_bold(ctx):
     await say(ctx, OWNER, "/caption custom {filename}")
     ev = await say_formatted(ctx, OWNER, "/caption [b]reset[/b]")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b>" and "Caption template saved" in ev.texts[0]
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>" and "Caption template saved" in ev.texts[0]
 
 
 async def test_a_variable_cut_by_the_formatting_is_still_a_whole_variable(ctx):
     """Double-tapping {filename} selects the word without its braces: the bold covers the whole variable all the same."""
     ev = await say_formatted(ctx, OWNER, "/caption {[b]filename[/b]} · {siz[i]e} left[/i]")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b> · <i>{size} left</i>"
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b> · <i>{size} left</i>"
     assert "Unknown" not in ev.texts[0]
 
 
 async def test_unknown_variables_are_still_reported(ctx):
     ev = await say_formatted(ctx, OWNER, "/caption [b]{filename}[/b] {nonsense}")
     assert "Unknown variables" in ev.texts[0] and "{nonsense}" in ev.texts[0]
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b> {nonsense}"
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b> {nonsense}"
 
 
 async def test_a_caption_that_is_too_long_with_its_link_addresses_is_refused(ctx):
     ev = await say_formatted(ctx, OWNER, f"/caption [a=https://example.com/{'a' * 800}]link[/a] {{filename}}")
     assert "too long" in ev.texts[0] and "link addresses" in ev.texts[0]
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</b>"
+    assert await autofmt(ctx) is None  # nothing was saved, so there is no format either
 
 
 # ---------------------------------------------------------------------------
@@ -94,7 +96,7 @@ async def test_the_set_caption_prompt_keeps_the_formatting(ctx):
     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 prefs(ctx))["caption"] == STORED
+    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
     assert STORED in text and "&lt;b&gt;" not in text  # the panel shows the caption formatted
@@ -104,17 +106,17 @@ async def test_the_set_caption_prompt_keeps_the_formatting(ctx):
 async def test_the_set_caption_prompt_still_takes_typed_html_and_reset(ctx):
     await click(ctx, OWNER, "in:caption")
     await say(ctx, OWNER, "<u>{filename}</u> {size}")
-    assert (await prefs(ctx))["caption"] == "<u>{filename}</u> {size}"
+    assert (await autofmt(ctx))["caption"] == "<u>{filename}</u> {size}"
     await click(ctx, OWNER, "in:caption")
     await say_formatted(ctx, OWNER, "[b]reset[/b]")
-    assert (await prefs(ctx))["caption"] == "<b>{filename}</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")
     await say_formatted(ctx, OWNER, "[b]{title}[/b] [i]{quality}[/i]")
-    assert (await prefs(ctx))["template"] == "{title} {quality}"
+    assert (await autofmt(ctx))["template"] == "{title} {quality}"
 
 
 async def test_a_prompt_that_is_refused_stays_open_for_another_try(ctx):
@@ -122,7 +124,7 @@ async def test_a_prompt_that_is_refused_stays_open_for_another_try(ctx):
     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")
-    assert OWNER not in ctx.app.pending and (await prefs(ctx))["caption"] == "<b>{filename}</b> ok"
+    assert OWNER not in ctx.app.pending and (await autofmt(ctx))["caption"] == "<b>{filename}</b> ok"
 
 
 # ---------------------------------------------------------------------------
@@ -131,7 +133,7 @@ async def test_a_prompt_that_is_refused_stays_open_for_another_try(ctx):
 
 
 async def test_a_formats_caption_prompt_keeps_the_formatting(ctx):
-    await ctx.db.update_settings(OWNER, caption="<u>{filename}</u>")
+    await say(ctx, OWNER, "/caption <u>{filename}</u>")  # the auto format in use has a caption of its own
     fmt = await make_format(ctx)
     i = fmt["id"]
     cb = await click(ctx, OWNER, f"fm:in:{i}:caption", msg_id=710)
@@ -139,7 +141,7 @@ async def test_a_formats_caption_prompt_keeps_the_formatting(ctx):
     ev = await say_formatted(ctx, OWNER, FORMATTED)
     assert ev.deleted and OWNER not in ctx.app.pending
     assert (await ctx.db.get_format(OWNER, i))["caption"] == STORED
-    assert (await prefs(ctx))["caption"] == "<u>{filename}</u>"  # the user's own caption was never touched
+    assert (await autofmt(ctx))["caption"] == "<u>{filename}</u>"  # the auto format in use was never touched
     chat, text, kw = ctx.client.edited[-1]
     assert kw["message"] == 710 and "Caption template saved" in text
     assert "<b>Caption</b> ▸ " + STORED in text and "· default" not in text  # the format's screen shows it formatted
@@ -197,7 +199,7 @@ async def test_a_link_in_a_caption_gets_no_link_preview_on_any_screen_that_shows
 
 async def test_the_formatting_follows_the_values_that_replace_the_variables(ctx):
     await say_formatted(ctx, OWNER, "/caption [b]{filename}[/b] · [i]{size}[/i] · [a=https://t.me/x]{original}[/a]")
-    caption = make_caption((await prefs(ctx))["caption"], new_name="One Piece - E5.mkv", orig_name="1147 - One Piece [Dual].mkv",
+    caption = make_caption((await autofmt(ctx))["caption"], new_name="One Piece - E5.mkv", orig_name="1147 - One Piece [Dual].mkv",
                            ext=".mkv", size=1536, duration=0)
     text, entities = telegram_html.parse(caption)  # what Telegram makes of it when it is sent with parse_mode="html"
     assert text == "One Piece - E5 · 1.50 KB · 1147 - One Piece [Dual].mkv"
@@ -211,7 +213,7 @@ async def test_the_formatting_follows_the_values_that_replace_the_variables(ctx)
 
 async def test_a_name_with_html_characters_cannot_break_the_formatting(ctx):
     await say_formatted(ctx, OWNER, "/caption [b]{filename}[/b] [i]{original}[/i]")
-    caption = make_caption((await prefs(ctx))["caption"], new_name="Tom & <Jerry>.mkv", orig_name="a<b>&c.mkv", ext=".mkv", size=1, duration=0)
+    caption = make_caption((await autofmt(ctx))["caption"], new_name="Tom & <Jerry>.mkv", orig_name="a<b>&c.mkv", ext=".mkv", size=1, duration=0)
     text, entities = telegram_html.parse(caption)
     assert text == "Tom & <Jerry> a<b>&c.mkv"
     assert [(type(e).__name__, e.offset, e.length) for e in entities] == [("MessageEntityBold", 0, 13), ("MessageEntityItalic", 14, 10)]

tests/test_check.py

@@ -81,3 +81,18 @@ async def test_check_is_in_the_command_menu(ctx):
     from bot.app import COMMANDS
 
     assert "check" in dict(COMMANDS)
+
+
+async def test_the_new_name_is_the_one_the_auto_format_in_use_would_give(ctx):
+    await ctx.db.create_format(OWNER, "One", "One - E{episode}", kind="auto")
+    two = await ctx.db.create_format(OWNER, "Two", "Two - {title} {3episode}", kind="auto")
+    await ctx.db.create_format(OWNER, "Manual", "Manual - {title}")  # a manual format is for /rename, not for the automatic renames
+    reply = document_message("1147 - One Piece [Dual] 720p.mkv")
+    assert "<code>One - E1147.mkv</code>" in (await say(ctx, OWNER, "/check", reply=reply)).texts[0]
+    await ctx.db.select_auto_format(OWNER, two["id"])
+    assert "<code>Two - One Piece 1147.mkv</code>" in (await say(ctx, OWNER, "/check", reply=reply)).texts[0]
+
+
+async def test_without_an_auto_format_the_new_name_follows_the_built_in_template(ctx):
+    ev = await say(ctx, OWNER, "/check", reply=document_message("[SubsPlease] Tokyo Revengers - 05 (1080p) [ABCD1234].mkv"))
+    assert "<code>[S01E05] Tokyo Revengers [1080p].mkv</code>" in ev.texts[0]

tests/test_db.py

@@ -1,6 +1,9 @@
+import json
+
 import pytest
 
-from bot.db import DEFAULT_SETTINGS, Database, normalize_database_url
+from bot.db import AUTO_FORMATS_MIGRATION, DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_SETTINGS, Database, Format, User, normalize_database_url
+from bot.parser import DEFAULT_TEMPLATE
 
 
 @pytest.fixture
@@ -43,15 +46,7 @@ async def test_unknown_setting_rejected(db):
         await db.update_settings(1, nope=1)
 
 
-async def test_thumb_and_stats(db):
-    assert not await db.has_thumb(5)
-    await db.set_thumb(5, b"\xff\xd8jpeg")
-    assert await db.has_thumb(5)
-    assert await db.get_thumb(5) == b"\xff\xd8jpeg"
-    await db.set_thumb(5, None)
-    assert not await db.has_thumb(5)
-    assert await db.get_thumb(5) is None
-
+async def test_stats(db):
     await db.record_job(5, 1000)
     await db.record_job(5, 24)
     await db.get_settings(6)
@@ -111,7 +106,7 @@ async def test_first_use_by_many_concurrent_handlers_does_not_collide(db):
     results = await asyncio.gather(*(db.get_settings(77) for _ in range(8)))
     assert all(r == DEFAULT_SETTINGS for r in results)
     # the same goes for the other writers that create the row on first use
-    await asyncio.gather(*(db.record_job(78, 10) for _ in range(5)), *(db.set_thumb(79, b"x") for _ in range(5)))
+    await asyncio.gather(*(db.record_job(78, 10) for _ in range(5)), *(db.update_settings(79, mode="caption") for _ in range(5)))
     assert await db.count_users() == 3
 
 
@@ -121,17 +116,19 @@ async def test_first_use_by_many_concurrent_handlers_does_not_collide(db):
 
 
 async def test_captions_are_bold_by_default(db):
-    assert DEFAULT_SETTINGS["caption"] == "<b>{filename}</b>"
-    assert (await db.get_settings(1))["caption"] == "<b>{filename}</b>"
+    assert DEFAULT_CAPTION == DEFAULT_FORMAT["caption"] == "<b>{filename}</b>"
+    assert (await db.create_format(1, "New", kind="auto"))["caption"] == "<b>{filename}</b>"
+    assert "caption" not in DEFAULT_SETTINGS and "template" not in DEFAULT_SETTINGS  # they live in the formats now
 
 
 async def test_the_plain_default_caption_of_earlier_versions_becomes_bold_once(db):
     import json
 
-    from bot.db import BOLD_CAPTION_MIGRATION, User
+    from bot.db import AUTO_FORMATS_MIGRATION, BOLD_CAPTION_MIGRATION, User
 
-    # what an older version left behind: no marker yet, and the settings stored in full
+    # what an older version left behind: no markers yet, and the settings stored in full
     await db.kv_delete(BOLD_CAPTION_MIGRATION)
+    await db.kv_delete(AUTO_FORMATS_MIGRATION)
     stored = {
         1: {"caption": "{filename}", "mode": "caption", "template": "T {title}"},  # still the old default
         2: {"caption": "{filename} · {size}"},  # their own caption
@@ -144,21 +141,27 @@ async def test_the_plain_default_caption_of_earlier_versions_becomes_bold_once(d
             session.add(User(id=uid, settings=value if isinstance(value, str) else json.dumps(value)))
         await session.commit()
 
-    await db.init()  # runs the migration
+    await db.init()  # runs the migrations
     fresh = Database(db.url)  # a new instance has no cache
     try:
+        # the old default became the bold one, and the old template and caption became an auto format
         s1 = await fresh.get_settings(1)
-        assert s1["caption"] == "<b>{filename}</b>" and s1["mode"] == "caption" and s1["template"] == "T {title}"
-        assert (await fresh.get_settings(2))["caption"] == "{filename} · {size}"
-        assert (await fresh.get_settings(3))["caption"] == "<b>{filename}</b>"
+        assert s1["mode"] == "caption"
+        (one,) = await fresh.list_formats(1, "auto")
+        assert one["name"] == "Default" and one["caption"] == "<b>{filename}</b>" and one["template"] == "T {title}"
+        assert s1["auto_format"] == one["id"]
+        (two,) = await fresh.list_formats(2, "auto")
+        assert two["caption"] == "{filename} · {size}" and two["template"] == DEFAULT_FORMAT["template"]
+        assert await fresh.list_formats(3) == [] and (await fresh.get_settings(3))["mode"] == "caption"  # nothing of theirs to keep
         assert await fresh.get_settings(4) == DEFAULT_SETTINGS and await fresh.get_settings(5) == DEFAULT_SETTINGS
-        await fresh.update_settings(1, caption="{filename}")  # going back to a plain caption afterwards...
+        await fresh.update_format(1, one["id"], caption="{filename}")  # going back to a plain caption afterwards...
     finally:
         await fresh.close()
     await db.init()
     again = Database(db.url)
     try:
-        assert (await again.get_settings(1))["caption"] == "{filename}"  # ...sticks, also across restarts
+        assert (await again.get_format(1, one["id"]))["caption"] == "{filename}"  # ...sticks, also across restarts
+        assert len(await again.list_formats(1)) == 1  # and the migrations ran only once
     finally:
         await again.close()
 
@@ -219,3 +222,139 @@ async def test_copy_format_stops_at_the_limit(db):
     with pytest.raises(FormatError) as raised:
         await db.copy_format(2, 1, src["id"])
     assert raised.value.code == "limit" and await db.count_formats(2) == MAX_FORMATS
+
+
+# ---------------------------------------------------------------------------
+# from the global template, caption and thumbnail to auto formats
+# ---------------------------------------------------------------------------
+
+META = {"title": "My Title", "author": "", "artist": "", "audio": "", "subtitle": "", "video": ""}
+
+
+async def start_after_an_old_version(db, users, formats=()):
+    """Store what a version without auto formats left behind (no marker yet), start the bot on it and return a fresh Database.
+
+    ``users``: ``{id: (stored settings, old thumbnail)}``; ``formats``: ``[(user id, name, stored data, thumbnail)]`` - formats of
+    that version had no kind.
+    """
+    await db.kv_delete(AUTO_FORMATS_MIGRATION)
+    async with db._sessions() as session:
+        for uid, (settings, thumb) in users.items():
+            session.add(User(id=uid, settings=json.dumps(settings), thumb=thumb))
+        for uid, name, data, thumb in formats:
+            session.add(Format(user_id=uid, name=name, data=json.dumps(data), thumb=thumb))
+        await session.commit()
+    await db.init()
+    return Database(db.url)  # a new instance has no cache
+
+
+async def test_the_old_template_caption_and_thumbnail_become_the_auto_format_default(db):
+    fresh = await start_after_an_old_version(
+        db, {1: ({"template": "T {title}", "caption": "<i>{filename}</i>", "mode": "caption"}, b"\xff\xd8old")}
+    )
+    try:
+        (auto,) = await fresh.list_formats(1)
+        assert (auto["name"], auto["kind"]) == ("Default", "auto")
+        assert auto["template"] == "T {title}" and auto["caption"] == "<i>{filename}</i>" and auto["has_thumb"]
+        assert await fresh.get_format_thumb(1, auto["id"]) == b"\xff\xd8old"
+        settings = await fresh.get_settings(1)
+        assert settings["auto_format"] == auto["id"] and settings["mode"] == "caption"  # in use, the rest of the settings is untouched
+        assert (await fresh.get_auto_format(1))["id"] == auto["id"]
+        async with fresh._sessions() as session:  # and nothing is kept in two places
+            row = await session.get(User, 1)
+            assert row.thumb is None and {"template", "caption"}.isdisjoint(json.loads(row.settings))
+    finally:
+        await fresh.close()
+
+
+async def test_the_old_metadata_stays_as_the_default_metadata_and_is_not_copied_into_the_auto_format(db):
+    users = {
+        1: ({"template": "A {title}", "metadata_on": True, "meta": META, "keep_audio": ["english"]}, None),
+        2: ({"template": "B {title}", "metadata_on": False, "meta": META, "keep_audio": ["english"]}, None),
+        3: ({"metadata_on": True, "meta": META}, None),  # nothing else of its own
+    }
+    fresh = await start_after_an_old_version(db, users)
+    try:
+        for uid, template in ((1, "A {title}"), (2, "B {title}")):
+            (auto,) = await fresh.list_formats(uid)
+            # no snapshot: it has none of its own, so the default metadata applies to it while it is On, edits included
+            assert auto["template"] == template and not any(auto["meta"].values()) and auto["keep_audio"] == [] and auto["keep_subtitle"] == []
+        assert await fresh.list_formats(3) == []  # nothing to keep: the built-in defaults are used
+        for uid in (1, 2, 3):  # the metadata is where it always was
+            settings = await fresh.get_settings(uid)
+            assert settings["meta"]["title"] == "My Title" and settings["metadata_on"] is (uid in (1, 3))
+        assert (await fresh.get_settings(2))["keep_audio"] == ["english"] and (await fresh.get_settings(1))["keep_audio"] == ["english"]
+    finally:
+        await fresh.close()
+
+
+async def test_formats_made_before_the_kinds_are_manual_and_the_ones_without_a_thumbnail_keep_the_old_one(db):
+    fresh = await start_after_an_old_version(
+        db,
+        {1: ({"template": "T"}, b"old-1"), 2: ({}, b"old-2"), 3: ({}, None)},
+        formats=[
+            (1, "Own thumb", {"template": "X"}, b"own"), (1, "Borrowing", {"template": "Y"}, None),
+            (2, "Other", {}, None), (3, "Plain", {}, None),
+        ],
+    )
+    try:
+        own, borrowing = await fresh.list_formats(1, "manual")
+        assert (own["name"], borrowing["name"]) == ("Own thumb", "Borrowing") and own["template"] == "X"
+        assert await fresh.get_format_thumb(1, own["id"]) == b"own"  # it had one of its own
+        assert await fresh.get_format_thumb(1, borrowing["id"]) == b"old-1"  # it used the old global one: it still does
+        (auto,) = await fresh.list_formats(1, "auto")
+        assert await fresh.get_format_thumb(1, auto["id"]) == b"old-1"
+
+        (other,) = await fresh.list_formats(2, "manual")
+        assert await fresh.get_format_thumb(2, other["id"]) == b"old-2"
+        (their_auto,) = await fresh.list_formats(2, "auto")  # a thumbnail alone is something to keep
+        assert their_auto["template"] == DEFAULT_TEMPLATE and their_auto["has_thumb"]
+
+        (plain,) = await fresh.list_formats(3)
+        assert plain["kind"] == "manual" and not plain["has_thumb"] and await fresh.get_auto_format(3) is None
+    finally:
+        await fresh.close()
+
+
+async def test_someone_who_never_changed_anything_gets_no_auto_format(db):
+    fresh = await start_after_an_old_version(db, {1: ({}, None), 2: ({"template": DEFAULT_TEMPLATE, "caption": DEFAULT_CAPTION}, None)})
+    try:
+        for uid in (1, 2):
+            assert await fresh.list_formats(uid) == [] and (await fresh.get_settings(uid))["auto_format"] == 0
+            assert await fresh.get_auto_format(uid) is None
+    finally:
+        await fresh.close()
+
+
+async def test_the_migration_makes_each_users_auto_format_once(db):
+    fresh = await start_after_an_old_version(db, {1: ({"template": "T"}, b"t")})
+    await fresh.close()
+    await db.kv_delete(AUTO_FORMATS_MIGRATION)  # as if the marker was lost: the user's own mark is what counts
+    await db.init()
+    again = Database(db.url)
+    try:
+        assert len(await again.list_formats(1)) == 1
+        assert await again.kv_get(AUTO_FORMATS_MIGRATION) == "done"
+    finally:
+        await again.close()
+
+
+async def test_settings_that_cannot_be_read_are_left_as_they_are(db):
+    await db.kv_delete(AUTO_FORMATS_MIGRATION)
+    async with db._sessions() as session:
+        session.add(User(id=1, settings="not json", thumb=b"x"))
+        session.add(User(id=2, settings="[1, 2]"))
+        await session.commit()
+    await db.init()
+    async with db._sessions() as session:
+        assert (await session.get(User, 1)).settings == "not json" and (await session.get(User, 2)).settings == "[1, 2]"
+    assert await db.list_formats(1) == [] and await db.list_formats(2) == []
+
+
+async def test_a_new_installation_just_notes_that_nothing_needs_changing(tmp_path):
+    fresh = Database(f"sqlite+aiosqlite:///{tmp_path}/new.db")
+    await fresh.init()
+    try:
+        assert await fresh.kv_get(AUTO_FORMATS_MIGRATION) == "done" and await fresh.count_users() == 0
+    finally:
+        await fresh.close()

tests/test_ethumb.py

@@ -10,7 +10,7 @@ from telethon import types
 
 from bot import app as appmod
 
-from .appkit import OWNER, STRANGER, click, data_of, jpeg, say, send_doc
+from .appkit import OWNER, STRANGER, auto_thumb, click, data_of, jpeg, say, send_doc
 from .conftest import needs_ffmpeg
 from .tgfakes import FakeEvent, FakeMessage, dispatch, document_message
 
@@ -164,7 +164,7 @@ async def test_it_handles_one_file_per_command(ctx):
 async def test_a_photo_while_waiting_still_sets_the_thumbnail_as_usual(ctx):
     await say(ctx, OWNER, "/ethumb")
     await dispatch(ctx.client, FakeEvent(OWNER, message=FakeMessage("", photo=True, mid=80), photo_bytes=jpeg()))
-    assert await ctx.db.has_thumb(OWNER) and ctx.app.modes[OWNER].kind == "ethumb"
+    assert await auto_thumb(ctx) and ctx.app.modes[OWNER].kind == "ethumb"
 
 
 async def test_cancel_and_the_stop_button_end_it(ctx):

tests/test_formats.py

@@ -1,8 +1,15 @@
+import asyncio
+
 import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from bot.db import DEFAULT_FORMAT, DEFAULT_SETTINGS, MAX_FORMATS, Database
+from bot.db import DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_SETTINGS, MAX_FORMATS, Database
 from bot.errors import FormatError
-from bot.formats import NAME_MAX, FormatSettings, apply_format, has_metadata, validate_name
+from bot.formats import (
+    NAME_MAX, AutoFormatSettings, FormatSettings, apply_format, default_auto_format, default_metadata_changes, has_default_metadata,
+    has_metadata, other_kind, validate_name,
+)
+from bot.parser import DEFAULT_TEMPLATE
 from bot.settings_ops import apply_setting
 
 U, V = 111, 222
@@ -128,7 +135,7 @@ def test_validate_name():
 
 
 def fmt_with(**kw):
-    base = {"id": 1, "name": "F", "has_thumb": False, "template": "T {title}", "caption": DEFAULT_FORMAT["caption"],
+    base = {"id": 1, "name": "F", "kind": "manual", "has_thumb": False, "template": "T {title}", "caption": DEFAULT_FORMAT["caption"],
             "meta": dict(DEFAULT_FORMAT["meta"]), "keep_audio": [], "keep_subtitle": []}
     base.update(kw)
     return base
@@ -137,17 +144,17 @@ def fmt_with(**kw):
 def test_apply_format_lays_the_format_over_the_settings_without_mutating_them():
     settings = dict(DEFAULT_SETTINGS, mode="caption", caption="<i>{original}</i>", file_type="document", remove_words=["x"],
                     target_channel=-100123, metadata_on=False, keep_audio=["french"])
-    settings["meta"] = dict(DEFAULT_SETTINGS["meta"], title="GLOBAL TITLE")
+    settings["meta"] = dict(DEFAULT_SETTINGS["meta"], title="DEFAULT TITLE")
     fmt = fmt_with(template="One Piece - E{episode}", meta=dict(DEFAULT_FORMAT["meta"], author="@Me"), keep_subtitle=["english"])
     out = apply_format(settings, fmt)
     assert out["template"] == "One Piece - E{episode}"
-    assert out["meta"]["author"] == "@Me" and out["meta"]["title"] == ""  # the format's own metadata, not the global one
+    assert out["meta"]["author"] == "@Me" and out["meta"]["title"] == ""  # the format's own metadata, not the default metadata
     assert out["keep_audio"] == [] and out["keep_subtitle"] == ["english"]
     assert out["metadata_on"] is True
     assert out["caption"] == "<b>{filename}</b>"  # the format's own, not the user's <i>{original}</i>
     # everything else is still the user's
     assert (out["mode"], out["file_type"], out["remove_words"], out["target_channel"]) == ("caption", "document", ["x"], -100123)
-    assert settings["template"] == DEFAULT_SETTINGS["template"] and settings["meta"]["title"] == "GLOBAL TITLE"
+    assert "template" not in settings and settings["meta"]["title"] == "DEFAULT TITLE"
     assert settings["caption"] == "<i>{original}</i>"
 
 
@@ -164,7 +171,7 @@ def test_a_format_brings_its_own_caption_and_never_borrows_the_users():
 
 def test_a_format_without_metadata_leaves_the_file_alone():
     assert not has_metadata(fmt_with())
-    settings = dict(DEFAULT_SETTINGS, metadata_on=True)  # global metadata on, but the format sets nothing
+    settings = dict(DEFAULT_SETTINGS, metadata_on=True)  # default metadata on, but the format sets nothing
     assert apply_format(settings, fmt_with())["metadata_on"] is False
     assert has_metadata(fmt_with(keep_audio=["1"])) and has_metadata(fmt_with(meta=dict(DEFAULT_FORMAT["meta"], video="v")))
 
@@ -174,7 +181,7 @@ def test_a_format_without_metadata_leaves_the_file_alone():
 # ---------------------------------------------------------------------------
 
 
-async def test_settings_ops_edit_a_format_with_the_same_rules_as_the_global_settings(db):
+async def test_settings_ops_edit_a_format_with_the_same_rules_as_the_users_own_settings(db):
     fmt = await db.create_format(U, "One Piece")
     store = FormatSettings(db, fmt["id"])
 
@@ -221,7 +228,7 @@ async def test_editing_a_deleted_format_raises_lookup_error(db):
 
 async def test_a_format_starts_with_the_file_name_in_bold_and_keeps_a_caption_of_its_own(db):
     fmt = await db.create_format(U, "One Piece")
-    assert fmt["caption"] == "<b>{filename}</b>" == DEFAULT_SETTINGS["caption"]
+    assert fmt["caption"] == "<b>{filename}</b>" == DEFAULT_CAPTION
     out = await db.update_format(U, fmt["id"], caption="<i>{filename}</i> · {size}")
     assert out["caption"] == "<i>{filename}</i> · {size}"
     await db.update_format(U, fmt["id"], template="X {title}", meta={"title": "T"})  # other edits leave it alone
@@ -229,7 +236,7 @@ async def test_a_format_starts_with_the_file_name_in_bold_and_keeps_a_caption_of
     assert (await other.get_format(U, fmt["id"]))["caption"] == "<i>{filename}</i> · {size}"
     await other.close()
     assert (await db.list_formats(U))[0]["caption"] == "<i>{filename}</i> · {size}"
-    assert await db.get_settings(U) == DEFAULT_SETTINGS  # the user's own caption is a different thing
+    assert await db.get_settings(U) == DEFAULT_SETTINGS  # formats never touch the user's own settings
 
 
 async def test_formats_saved_before_captions_existed_get_the_default_one(db):
@@ -256,14 +263,14 @@ async def test_a_copy_of_a_format_has_its_caption(db):
     assert (await db.get_format(U, fmt["id"]))["caption"] == "<code>{filename}</code>"
 
 
-async def test_settings_ops_edit_a_formats_caption_with_the_checks_of_the_global_one(db):
+async def test_settings_ops_edit_a_formats_caption_with_the_checks_of_the_auto_format_caption(db):
     fmt = await db.create_format(U, "One Piece")
     store = FormatSettings(db, fmt["id"])
     ok, msg = await apply_setting(store, U, "caption", "<b>{filename}</b> · {size} · {duration}")
     assert ok and "Caption template saved" in msg and "Unknown" not in msg
     assert (await db.get_format(U, fmt["id"]))["caption"] == "<b>{filename}</b> · {size} · {duration}"
     ok, msg = await apply_setting(store, U, "caption", "<i>{nonsense}</i>")
-    assert ok and "Unknown variables" in msg and "{nonsense}" in msg  # kept as plain text, like for the global one
+    assert ok and "Unknown variables" in msg and "{nonsense}" in msg  # kept as plain text, as for /caption
     ok, msg = await apply_setting(store, U, "caption", "x" * 801)
     assert not ok and "too long" in msg and (await db.get_format(U, fmt["id"]))["caption"] == "<i>{nonsense}</i>"
     ok, msg = await apply_setting(store, U, "caption", "")
@@ -274,3 +281,269 @@ async def test_settings_ops_edit_a_formats_caption_with_the_checks_of_the_global
         assert ok and (await db.get_format(U, fmt["id"]))["caption"] == "<b>{filename}</b>", word  # the file name in bold again
     assert (await store.get_settings(U))["caption"] == "<b>{filename}</b>"
     assert await db.get_settings(U) == DEFAULT_SETTINGS
+
+
+# ---------------------------------------------------------------------------
+# two kinds: 12 auto formats and 12 manual ones
+# ---------------------------------------------------------------------------
+
+
+async def test_a_format_is_manual_unless_it_is_made_as_an_auto_one(db):
+    assert (await db.create_format(U, "A"))["kind"] == "manual"
+    assert (await db.create_format(U, "B", kind="manual"))["kind"] == "manual"
+    auto = await db.create_format(U, "C", kind="auto")
+    assert auto["kind"] == "auto" and (await db.get_format(U, auto["id"]))["kind"] == "auto"
+    with pytest.raises(KeyError):
+        await db.create_format(U, "D", kind="both")
+    assert other_kind("auto") == "manual" and other_kind("manual") == "auto"
+
+
+async def test_each_kind_lists_and_counts_its_own_formats(db):
+    a1, m1, a2 = await db.create_format(U, "A1", kind="auto"), await db.create_format(U, "M1"), await db.create_format(U, "A2", kind="auto")
+    await db.create_format(V, "Theirs", kind="auto")
+    assert [f["id"] for f in await db.list_formats(U)] == [a1["id"], m1["id"], a2["id"]]  # no kind: all of them, oldest first
+    assert [f["id"] for f in await db.list_formats(U, "auto")] == [a1["id"], a2["id"]]
+    assert [f["id"] for f in await db.list_formats(U, "manual")] == [m1["id"]]
+    assert (await db.count_formats(U), await db.count_formats(U, "auto"), await db.count_formats(U, "manual")) == (3, 2, 1)
+    assert await db.count_formats(V, "manual") == 0 and await db.count_formats(V, "auto") == 1
+
+
+async def test_a_user_can_save_twelve_formats_of_each_kind_and_no_more(db):
+    for kind in ("auto", "manual"):
+        for i in range(MAX_FORMATS):
+            await db.create_format(U, f"{kind} {i}", kind=kind)
+        with pytest.raises(FormatError) as exc:
+            await db.create_format(U, "One too many", kind=kind)
+        assert exc.value.code == "limit"
+    assert await db.count_formats(U) == 2 * MAX_FORMATS
+    first = (await db.list_formats(U, "auto"))[0]
+    assert await db.delete_format(U, first["id"])
+    await db.create_format(U, "One too many", kind="auto")  # a slot of that kind is free again
+    with pytest.raises(FormatError):
+        await db.create_format(U, "Still too many", kind="manual")  # the manual ones are still full
+
+
+async def test_a_name_only_has_to_be_free_within_its_kind(db):
+    auto = await db.create_format(U, "One Piece", kind="auto")
+    manual = await db.create_format(U, "ONE PIECE")  # the same name, the other kind
+    with pytest.raises(FormatError) as exc:
+        await db.create_format(U, "one piece", kind="auto")
+    assert exc.value.code == "taken"
+    other = await db.create_format(U, "Dragon Ball", kind="auto")
+    with pytest.raises(FormatError):
+        await db.update_format(U, other["id"], name="one piece")  # taken by an auto format
+    await db.update_format(U, other["id"], name="Dragon Ball Z")
+    await db.update_format(U, manual["id"], name="Dragon Ball Z")  # but free among the manual ones
+    assert (await db.get_format(U, auto["id"]))["name"] == "One Piece"
+
+
+async def test_formats_stored_before_there_were_kinds_are_manual(db):
+    import json
+
+    from bot.db import Format
+
+    async with db._sessions() as session:
+        session.add(Format(user_id=U, name="Old", data=json.dumps({"template": "Old - {title}"})))
+        session.add(Format(user_id=U, name="Odd", data=json.dumps({"kind": "sideways"})))
+        session.add(Format(user_id=U, name="Auto", data=json.dumps({"kind": "auto"})))
+        await session.commit()
+    assert [(f["name"], f["kind"]) for f in await db.list_formats(U)] == [("Old", "manual"), ("Odd", "manual"), ("Auto", "auto")]
+    old = (await db.list_formats(U, "manual"))[0]
+    out = await db.update_format(U, old["id"], template="New - {title}")  # editing a format keeps its kind
+    assert out["kind"] == "manual" and (await db.get_format(U, old["id"]))["template"] == "New - {title}"
+    auto = (await db.list_formats(U, "auto"))[0]
+    assert (await db.update_format(U, auto["id"], meta={"title": "T"}))["kind"] == "auto"
+
+
+async def test_copy_format_to_the_other_kind(db):
+    src = await db.create_format(U, "One Piece", "E{episode}", kind="auto")
+    await db.update_format(U, src["id"], meta={"title": "OP"}, keep_audio=["japanese"], caption="<i>{filename}</i>")
+    await db.set_format_thumb(U, src["id"], b"\xff\xd8thumb")
+
+    same = await db.copy_format(V, U, src["id"])  # sharing: the copy keeps the kind
+    assert same["kind"] == "auto"
+    mine = await db.copy_format(U, U, src["id"], kind="manual")
+    assert mine["kind"] == "manual" and mine["name"] == "One Piece" and mine["id"] != src["id"]  # free in the manual names
+    assert mine["template"] == "E{episode}" and mine["meta"]["title"] == "OP" and mine["keep_audio"] == ["japanese"]
+    assert mine["caption"] == "<i>{filename}</i>" and mine["has_thumb"] and await db.get_format_thumb(U, mine["id"]) == b"\xff\xd8thumb"
+    assert [(await db.copy_format(U, U, src["id"], kind="manual"))["name"] for _ in range(2)] == ["One Piece (2)", "One Piece (3)"]
+    back = await db.copy_format(U, U, mine["id"], kind="auto")  # and the other way round: "One Piece" is taken among the auto ones
+    assert back["kind"] == "auto" and back["name"] == "One Piece (2)"
+    await db.update_format(U, mine["id"], template="Changed")  # the copy is independent
+    assert (await db.get_format(U, src["id"]))["template"] == "E{episode}"
+    with pytest.raises(KeyError):
+        await db.copy_format(U, U, src["id"], kind="both")
+
+
+async def test_copying_to_the_other_kind_stops_at_the_limit_of_that_kind(db):
+    src = await db.create_format(U, "One Piece", kind="auto")
+    for i in range(MAX_FORMATS):
+        await db.create_format(U, f"M{i}")
+    with pytest.raises(FormatError) as exc:
+        await db.copy_format(U, U, src["id"], kind="manual")
+    assert exc.value.code == "limit" and await db.count_formats(U, "manual") == MAX_FORMATS
+    assert (await db.copy_format(U, U, src["id"]))["kind"] == "auto"  # the auto ones have room
+
+
+# ---------------------------------------------------------------------------
+# the auto format in use
+# ---------------------------------------------------------------------------
+
+
+async def test_without_auto_formats_there_is_none_in_use(db):
+    assert await db.get_auto_format(U) is None
+    await db.create_format(U, "Manual only")  # a manual format never renames files by itself
+    assert await db.get_auto_format(U) is None and (await db.get_settings(U))["auto_format"] == 0
+
+
+async def test_the_first_auto_format_is_in_use_and_it_is_remembered(db):
+    first = await db.create_format(U, "First", kind="auto")
+    await db.create_format(U, "Second", kind="auto")
+    assert (await db.get_auto_format(U))["id"] == first["id"]
+    assert (await db.get_settings(U))["auto_format"] == first["id"]
+    assert (await db.get_auto_format(V)) is None  # per user
+
+
+async def test_selecting_an_auto_format(db):
+    a, b = await db.create_format(U, "A", kind="auto"), await db.create_format(U, "B", kind="auto")
+    manual = await db.create_format(U, "M")
+    theirs = await db.create_format(V, "Theirs", kind="auto")
+    assert (await db.select_auto_format(U, b["id"]))["id"] == b["id"]
+    assert (await db.get_auto_format(U))["id"] == b["id"] and (await db.get_settings(U))["auto_format"] == b["id"]
+    for fid in (manual["id"], theirs["id"], 99999):  # not an auto format of theirs
+        assert await db.select_auto_format(U, fid) is None
+    assert (await db.get_auto_format(U))["id"] == b["id"]  # unchanged by the refusals
+    await db.select_auto_format(U, a["id"])
+    assert (await db.get_auto_format(U))["id"] == a["id"]
+
+
+async def test_deleting_the_auto_format_in_use_hands_over_to_another(db):
+    a = await db.create_format(U, "A", kind="auto")
+    b = await db.create_format(U, "B", kind="auto")
+    c = await db.create_format(U, "C", kind="auto")
+    await db.select_auto_format(U, b["id"])
+    await db.delete_format(U, b["id"])
+    assert (await db.get_auto_format(U))["id"] == a["id"]  # the oldest left takes over
+    assert (await db.get_settings(U))["auto_format"] == a["id"]
+    await db.delete_format(U, c["id"])  # deleting one that is not in use changes nothing
+    assert (await db.get_auto_format(U))["id"] == a["id"]
+    await db.delete_format(U, a["id"])
+    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
+# ---------------------------------------------------------------------------
+
+
+def with_default_metadata(**over):
+    settings = dict(DEFAULT_SETTINGS, **over)
+    settings["meta"] = dict(DEFAULT_SETTINGS["meta"], title="DEFAULT TITLE", audio="{lang} Audio")
+    return settings
+
+
+def test_an_auto_format_without_metadata_leaves_the_default_metadata_in_charge():
+    mine = with_default_metadata(metadata_on=True, keep_audio=["english"])
+    out = apply_format(mine, fmt_with(kind="auto"))
+    assert out["template"] == "T {title}" and out["metadata_on"] is True  # its switch decides, as it always did
+    assert out["meta"]["title"] == "DEFAULT TITLE" and out["keep_audio"] == ["english"]
+    off = apply_format(with_default_metadata(metadata_on=False), fmt_with(kind="auto"))
+    assert off["metadata_on"] is False and off["meta"]["title"] == "DEFAULT TITLE"  # off: nothing is written
+
+
+def test_an_auto_format_with_metadata_of_its_own_ignores_the_default_metadata():
+    fmt = fmt_with(kind="auto", meta=dict(DEFAULT_FORMAT["meta"], author="@Me"))
+    out = apply_format(with_default_metadata(metadata_on=False), fmt)
+    assert out["metadata_on"] is True and out["meta"]["author"] == "@Me" and out["meta"]["title"] == "" and out["keep_audio"] == []
+    assert apply_format(with_default_metadata(metadata_on=True), fmt)["meta"]["title"] == ""
+
+
+def test_a_manual_format_never_uses_the_default_metadata():
+    out = apply_format(with_default_metadata(metadata_on=True, keep_audio=["english"]), fmt_with(kind="manual"))
+    assert out["metadata_on"] is False and out["meta"]["title"] == "" and out["keep_audio"] == []
+
+
+def test_no_auto_format_means_the_built_in_defaults_and_the_default_metadata():
+    built_in = default_auto_format()
+    assert built_in["kind"] == "auto" and built_in["template"] == DEFAULT_TEMPLATE and built_in["caption"] == DEFAULT_CAPTION
+    assert not built_in["has_thumb"] and not has_metadata(built_in)
+    mine = with_default_metadata(metadata_on=True, template="ignored")
+    out = apply_format(mine, None)
+    assert out["template"] == DEFAULT_TEMPLATE and out["caption"] == DEFAULT_CAPTION
+    assert out["metadata_on"] is True and out["meta"]["title"] == "DEFAULT TITLE"
+    assert built_in is not default_auto_format() and default_auto_format()["meta"] == DEFAULT_FORMAT["meta"]  # a fresh copy each time
+
+
+def test_default_metadata_is_what_the_user_set_in_the_metadata_menu():
+    assert not has_default_metadata(DEFAULT_SETTINGS)
+    assert not has_default_metadata(dict(DEFAULT_SETTINGS, metadata_on=True))  # the switch alone is not metadata
+    assert has_default_metadata(with_default_metadata())
+    assert has_default_metadata(dict(DEFAULT_SETTINGS, keep_audio=["1"])) and has_default_metadata(dict(DEFAULT_SETTINGS, keep_subtitle=["english"]))
+    changes = default_metadata_changes(with_default_metadata(keep_audio=["2", "1"], keep_subtitle=["english"]))
+    assert set(changes) == {"meta", "keep_audio", "keep_subtitle"}
+    assert changes["meta"]["title"] == "DEFAULT TITLE" and changes["keep_audio"] == ["2", "1"] and changes["keep_subtitle"] == ["english"]
+    source = with_default_metadata(keep_audio=["2"])
+    changes = default_metadata_changes(source)
+    changes["keep_audio"].append("3")
+    changes["meta"]["title"] = "other"
+    assert source["keep_audio"] == ["2"] and source["meta"]["title"] == "DEFAULT TITLE"  # copies, not the user's own lists
+
+
+async def test_default_metadata_can_be_copied_into_a_format_of_either_kind(db):
+    settings = with_default_metadata(keep_audio=["japanese"], keep_subtitle=["english"])
+    for kind in ("auto", "manual"):
+        fmt = await db.create_format(U, f"{kind} one", kind=kind)
+        await db.update_format(U, fmt["id"], meta={"video": "OLD"}, keep_audio=["french", "2"])
+        got = await db.update_format(U, fmt["id"], **default_metadata_changes(settings))
+        assert got["meta"]["title"] == "DEFAULT TITLE" and got["meta"]["audio"] == "{lang} Audio"
+        assert got["keep_audio"] == ["japanese"] and got["keep_subtitle"] == ["english"] and got["kind"] == kind
+        assert got["meta"]["video"] == "" and got["meta"]["author"] == ""  # all six fields are sent: it replaces what the format had

tests/test_formats_app.py

@@ -1,89 +1,149 @@
-"""/formats (the manager) and /rename (pick a format, send one file)."""
+"""/formats (the manager of auto and manual formats) and /rename (pick a manual format, send one file)."""
 import asyncio
 import time
 
+import pytest
+
 from bot import app as appmod
 from bot import panels
 from bot.db import MAX_FORMATS
+from bot.formats import KIND_LABELS
+from bot.parser import DEFAULT_TEMPLATE
 
-from .appkit import ADMIN_CFG, EPISODE, OWNER, click, data_of, jpeg, say, send_doc
-from .tgfakes import FakeEvent, FakeMessage, dispatch, document_message
+from .appkit import ADMIN_CFG, EPISODE, OWNER, autofmt, click, data_of, jpeg, say, send_doc
+from .tgfakes import FakeEvent, FakeMessage, dispatch, document_message, flat_buttons
 
 ONE_PIECE = "1147 - One Piece [Dual] 720p @Anime_X_Universe.mkv"
+KINDS = ["auto", "manual"]
 
 
-async def make_format(ctx, name="One Piece", uid=OWNER, **changes):
-    fmt = await ctx.db.create_format(uid, name, template="One Piece - E{episode}")
+async def make_format(ctx, name="One Piece", uid=OWNER, kind="manual", **changes):
+    fmt = await ctx.db.create_format(uid, name, template="One Piece - E{episode}", kind=kind)
     if changes:
         fmt = await ctx.db.update_format(uid, fmt["id"], **changes)
     return fmt
 
 
+def labels_of(buttons):
+    return [label for label, _data in flat_buttons(buttons)]
+
+
 # ---------------------------------------------------------------------------
-# the manager
+# the manager: /formats shows the two kinds, each kind has its own list
 # ---------------------------------------------------------------------------
 
 
-async def test_formats_command_lists_the_formats_and_offers_a_new_one(ctx):
-    ev = await say(ctx, OWNER, "/formats")
-    assert "FORMATS" in ev.texts[0] and "(0/12)" in ev.texts[0] and "no formats yet" in ev.texts[0]
-    assert "fm:new" in data_of(ev.out[0][1])
+async def test_formats_command_offers_the_two_kinds_with_their_counts(ctx):
+    for command in ("/formats", "/format", "/FORMAT@RenameBot"):
+        ev = await say(ctx, OWNER, command)
+        text, buttons, _kw = ev.out[0]
+        assert "FORMATS" in text and "Auto rename" in text and "Manual rename" in text, command
+        assert flat_buttons(buttons)[:2] == [("🤖 Auto rename (0/12)", "fm:l:auto"), ("✋ Manual rename (0/12)", "fm:l:manual")], command
+    await make_format(ctx, "Auto One", kind="auto")
+    await make_format(ctx, "One Piece")
+    await make_format(ctx, "Dragon Ball")
+    ev = await say(ctx, OWNER, "/format")
+    assert flat_buttons(ev.out[0][1])[:2] == [("🤖 Auto rename (1/12)", "fm:l:auto"), ("✋ Manual rename (2/12)", "fm:l:manual")]
+
 
+async def test_each_kind_has_its_own_list_and_its_own_new_button(ctx):
+    cb = await click(ctx, OWNER, "fm:l:manual")
+    text, buttons = cb.edits[-1]
+    assert "MANUAL FORMATS" in text and "(0/12)" in text and "no manual formats yet" in text and cb.answers
+    assert "fm:new:manual" in data_of(buttons) and "fm:new:auto" not in data_of(buttons)
+    cb = await click(ctx, OWNER, "fm:l:auto")
+    text, buttons = cb.edits[-1]
+    assert "AUTO FORMATS" in text and "no auto formats yet" in text and "fm:new:auto" in data_of(buttons)
+
+    auto = await make_format(ctx, "Auto One", kind="auto")
     a, b = await make_format(ctx, "One Piece"), await make_format(ctx, "Dragon Ball")
-    ev = await say(ctx, OWNER, "/formats")
-    data = data_of(ev.out[0][1])
-    assert "(2/12)" in ev.texts[0] and f"fm:v:{a['id']}" in data and f"fm:v:{b['id']}" in data and "fm:new" in data
-    labels = [label for row in ev.out[0][1] for label in [b.text for b in row]]
-    assert "One Piece" in labels and "Dragon Ball" in labels
+    text, buttons = (await click(ctx, OWNER, "fm:l:manual")).edits[-1]
+    data = data_of(buttons)
+    assert "(2/12)" in text and f"fm:v:{a['id']}" in data and f"fm:v:{b['id']}" in data and f"fm:v:{auto['id']}" not in data
+    assert "One Piece" in labels_of(buttons) and "Dragon Ball" in labels_of(buttons) and "Auto One" not in labels_of(buttons)
+    assert "fm:l:manual" not in data and "m:formats" in data  # the way back is the chooser
+
+    text, buttons = (await click(ctx, OWNER, "fm:l:auto")).edits[-1]
+    data = data_of(buttons)
+    assert "(1/12)" in text and f"fm:v:{auto['id']}" in data and f"fm:v:{a['id']}" not in data
+    assert "Auto One ✅" in labels_of(buttons)  # the one in use is ticked
+
+
+@pytest.mark.parametrize("data", ["fm:l", "fm:l:nope", "fm:new", "fm:new:nope"])
+async def test_a_button_without_a_known_kind_opens_the_choice(ctx, data):
+    """``fm:new`` is what the button of a message from before the two kinds sends: nothing is created, the user chooses a kind."""
+    cb = await click(ctx, OWNER, data)
+    text, buttons = cb.edits[-1]
+    assert "FORMATS" in text and data_of(buttons)[:2] == ["fm:l:auto", "fm:l:manual"] and cb.answers == [(None, False)]
+    assert OWNER not in ctx.app.pending and await ctx.db.count_formats(OWNER) == 0
 
 
 async def test_formats_are_reachable_from_the_home_menu(ctx):
     ev = await say(ctx, OWNER, "/start")
     assert "m:formats" in data_of(ev.out[0][1])
     cb = await click(ctx, OWNER, "m:formats")
-    assert "FORMATS" in cb.edits[-1][0] and cb.answers
+    assert "FORMATS" in cb.edits[-1][0] and cb.answers and "fm:l:auto" in data_of(cb.edits[-1][1])
 
 
-async def test_creating_a_format_asks_for_a_name_and_opens_it(ctx):
-    await say(ctx, OWNER, "/template Mine - {title}")
-    cb = await click(ctx, OWNER, "fm:new", msg_id=500)
+@pytest.mark.parametrize("kind", KINDS)
+async def test_creating_a_format_asks_for_a_name_and_opens_it(ctx, kind):
+    cb = await click(ctx, OWNER, f"fm:new:{kind}", msg_id=500)
     p = ctx.app.pending[OWNER]
-    assert p.kind == "fmt:new" and p.fid == 0 and p.msg_id == 500
-    assert cb.edits[-1][0] == panels.FORMAT_PROMPTS["new"] and data_of(cb.edits[-1][1]) == ["m:formats"]
+    assert p.kind == "fmt:new" and p.fid == 0 and p.msg_id == 500 and p.fmt_kind == kind
+    assert cb.edits[-1][0] == panels.FORMAT_PROMPTS["new"] and data_of(cb.edits[-1][1]) == [f"fm:l:{kind}"]
 
     ev = await say(ctx, OWNER, "  One   Piece ", mid=60)
     assert ev.deleted and OWNER not in ctx.app.pending
     (fmt,) = await ctx.db.list_formats(OWNER)
-    assert fmt["name"] == "One Piece" and fmt["template"] == "Mine - {title}"  # starts from the user's current template
+    assert fmt["name"] == "One Piece" and fmt["kind"] == kind and fmt["template"] == DEFAULT_TEMPLATE  # it starts from the defaults
     (chat, text, kw), = ctx.client.edited
-    assert kw["message"] == 500 and "created" in text and "🗂 One Piece" in text and f"fm:in:{fmt['id']}:template" in data_of(kw["buttons"])
+    assert kw["message"] == 500 and "created" in text and "🗂 One Piece" in text and KIND_LABELS[kind] in text
+    assert f"fm:in:{fmt['id']}:template" in data_of(kw["buttons"]) and f"fm:dm:{fmt['id']}" in data_of(kw["buttons"])
 
 
 async def test_a_bad_or_taken_name_keeps_the_prompt_open(ctx):
     await make_format(ctx, "One Piece")
-    await click(ctx, OWNER, "fm:new")
+    await click(ctx, OWNER, "fm:new:manual")
     for text, expected in (("x" * 31, "too long"), ("one piece", "already have a format")):
         ev = await say(ctx, OWNER, text)
         assert expected in ev.texts[0] and "Try again" in ev.texts[0]
         assert OWNER in ctx.app.pending and await ctx.db.count_formats(OWNER) == 1
-    cb = await click(ctx, OWNER, "m:formats")  # Cancel
-    assert OWNER not in ctx.app.pending and "FORMATS" in cb.edits[-1][0]
+    cb = await click(ctx, OWNER, "fm:l:manual")  # Cancel
+    assert OWNER not in ctx.app.pending and "MANUAL FORMATS" in cb.edits[-1][0]
+
+
+async def test_a_name_is_taken_only_within_its_own_kind(ctx):
+    await make_format(ctx, "One Piece", kind="auto")
+    await click(ctx, OWNER, "fm:new:manual")
+    await say(ctx, OWNER, "one piece")
+    assert OWNER not in ctx.app.pending
+    assert [f["kind"] for f in await ctx.db.list_formats(OWNER)] == ["auto", "manual"]
+    await click(ctx, OWNER, "fm:new:manual")
+    ev = await say(ctx, OWNER, "ONE PIECE")
+    assert "already have a format" in ev.texts[0] and OWNER in ctx.app.pending  # but not twice in the same kind
 
 
-async def test_the_twelve_format_limit(ctx):
+@pytest.mark.parametrize("kind", KINDS)
+async def test_the_twelve_format_limit_of_each_kind(ctx, kind):
+    other = "manual" if kind == "auto" else "auto"
     for i in range(MAX_FORMATS):
-        await make_format(ctx, f"F{i}")
-    ev = await say(ctx, OWNER, "/formats")
-    assert "all 12 formats" in ev.texts[0] and "fm:new" not in data_of(ev.out[0][1])
-    cb = await click(ctx, OWNER, "fm:new")
-    assert "already have 12" in cb.alerts[0] and OWNER not in ctx.app.pending
+        await make_format(ctx, f"F{i}", kind=kind)
+    cb = await click(ctx, OWNER, f"fm:l:{kind}")
+    assert f"all 12 {kind} formats" in cb.edits[-1][0] and f"fm:new:{kind}" not in data_of(cb.edits[-1][1])
+    cb = await click(ctx, OWNER, f"fm:new:{kind}")
+    assert f"already have 12 {kind} formats" in cb.alerts[0] and OWNER not in ctx.app.pending
+
+    # the other kind has its own twelve
+    cb = await click(ctx, OWNER, f"fm:new:{other}")
+    assert not cb.alerts and ctx.app.pending[OWNER].fmt_kind == other
+    await click(ctx, OWNER, f"fm:l:{other}")
 
     # the limit is also enforced when it is reached while the name prompt is open
-    await ctx.db.delete_format(OWNER, (await ctx.db.list_formats(OWNER))[0]["id"])
-    await click(ctx, OWNER, "fm:new")
-    await make_format(ctx, "Sneaked in")
+    await ctx.db.delete_format(OWNER, (await ctx.db.list_formats(OWNER, kind))[0]["id"])
+    await click(ctx, OWNER, f"fm:new:{kind}")
+    await make_format(ctx, "Sneaked in", kind=kind)
     ev = await say(ctx, OWNER, "Late one")
-    assert "already have 12" in ev.texts[0] and OWNER not in ctx.app.pending
+    assert f"already have 12 {kind} formats" in ev.texts[0] and OWNER not in ctx.app.pending
 
 
 async def test_the_format_screen_shows_every_field_and_has_a_button_for_each(ctx):
@@ -92,15 +152,17 @@ async def test_the_format_screen_shows_every_field_and_has_a_button_for_each(ctx
     text, buttons = cb.edits[-1]
     for label in ("Template", "Caption", "Thumbnail", "Title", "Author", "Artist", "Audio", "Subtitle", "Video", "Keep Audio", "Keep Subtitle"):
         assert label in text, label
-    assert "One Piece - E{episode}" in text and "Japanese, 2" in text and "your default thumbnail" in text
+    assert "One Piece - E{episode}" in text and "Japanese, 2" in text and panels.THUMB_NONE in text
     assert "<b>Title</b> ▸ <code>One Piece</code>" in text and "<b>Video</b> ▸ <code>HD</code>" in text  # values land on the right line
     assert "<b>Author</b> ▸ —" in text
+    assert "✋ Manual" in text.splitlines()[0]
     data = data_of(buttons)
     i = fmt["id"]
     for field in ("name", "template", "caption", "title", "author", "artist", "audio", "subtitle", "video", "keep_audio", "keep_subtitle"):
         assert f"fm:in:{i}:{field}" in data, field
-    assert {f"fm:th:{i}", f"fm:del:{i}", "m:formats", "x:close"} <= set(data)
+    assert {f"fm:th:{i}", f"fm:del:{i}", f"fm:dm:{i}", f"fm:cp:{i}", "fm:l:manual", "m:home", "x:close"} <= set(data)
     assert f"fm:thd:{i}" not in data  # nothing to delete yet
+    assert f"fm:use:{i}" not in data  # only an auto format is used for auto rename
     assert f"fm:cr:{i}" not in data and "<b>Caption</b> ▸ <b>{filename}</b> · default" in text  # nor to reset
 
 
@@ -129,9 +191,22 @@ async def test_editing_each_field_goes_through_the_same_checks_as_the_settings(c
         assert check(await ctx.db.get_format(OWNER, i)), field
         chat, text, kw = ctx.client.edited[-1]
         assert kw["message"] == 700 + n and "🗂 One Piece" in text, field  # the format screen is back in the same message
-    # none of this touched the user's own settings
+    # none of this touched the default metadata or the auto formats
     mine = await ctx.db.get_settings(OWNER)
-    assert mine["meta"]["title"] == "" and mine["keep_audio"] == [] and mine["caption"] == "<b>{filename}</b>"
+    assert mine["meta"]["title"] == "" and mine["keep_audio"] == [] and mine["metadata_on"] is False and await autofmt(ctx) is None
+
+
+async def test_an_auto_format_is_edited_in_the_same_way(ctx):
+    fmt = await make_format(ctx, "Auto One", kind="auto")
+    i = fmt["id"]
+    await click(ctx, OWNER, f"fm:in:{i}:template", msg_id=701)
+    await say(ctx, OWNER, "{title} - {2episode}")
+    await click(ctx, OWNER, f"fm:in:{i}:title", msg_id=702)
+    await say(ctx, OWNER, "One Piece")
+    got = await ctx.db.get_format(OWNER, i)
+    assert got["template"] == "{title} - {2episode}" and got["meta"]["title"] == "One Piece" and got["kind"] == "auto"
+    chat, text, kw = ctx.client.edited[-1]
+    assert kw["message"] == 702 and "🗂 Auto One" in text and "🤖 Auto" in text
 
 
 async def test_invalid_values_keep_the_prompt_open_and_cancel_returns_to_the_format(ctx):
@@ -155,14 +230,14 @@ async def test_clearing_a_field_with_off(ctx):
 
 
 async def test_a_formats_caption_is_its_own_and_can_be_reset(ctx):
-    await ctx.db.update_settings(OWNER, caption="<i>MY OWN {filename}</i>")
+    auto = await make_format(ctx, "Auto One", kind="auto", caption="<i>MY OWN {filename}</i>")
     fmt = await make_format(ctx)
     i = fmt["id"]
     cb = await click(ctx, OWNER, f"fm:in:{i}:caption", msg_id=710)
     assert cb.edits[-1][0] == panels.FORMAT_PROMPTS["caption"] and data_of(cb.edits[-1][1]) == [f"fm:cx:{i}"]
     assert "reset" in cb.edits[-1][0]
 
-    ev = await say(ctx, OWNER, "x" * 801)  # the same checks as the global caption: too long keeps the prompt open
+    ev = await say(ctx, OWNER, "x" * 801)  # the same checks as /caption: too long keeps the prompt open
     assert "too long" in ev.texts[0] and "Try again" in ev.texts[0] and OWNER in ctx.app.pending
     assert (await ctx.db.get_format(OWNER, i))["caption"] == "<b>{filename}</b>"
     ev = await say(ctx, OWNER, "<b>{filename}</b> · {size} · {nonsense}")
@@ -175,7 +250,7 @@ async def test_a_formats_caption_is_its_own_and_can_be_reset(ctx):
     cb = await click(ctx, OWNER, f"fm:cr:{i}")
     assert cb.toasts == ["Caption reset."] and (await ctx.db.get_format(OWNER, i))["caption"] == "<b>{filename}</b>"
     assert "· default" in cb.edits[-1][0] and f"fm:cr:{i}" not in data_of(cb.edits[-1][1])
-    assert (await ctx.db.get_settings(OWNER))["caption"] == "<i>MY OWN {filename}</i>"  # the user's own caption was never touched
+    assert (await autofmt(ctx))["caption"] == "<i>MY OWN {filename}</i>" and (await autofmt(ctx))["id"] == auto["id"]  # never touched
 
     await ctx.db.update_format(OWNER, i, caption="<u>{filename}</u>")  # sending reset in the prompt does the same
     await click(ctx, OWNER, f"fm:in:{i}:caption")
@@ -212,22 +287,25 @@ async def test_a_format_thumbnail_is_saved_shown_and_deleted(ctx):
 
     ev = FakeEvent(OWNER, message=FakeMessage("", mid=801, photo=True), photo_bytes=jpeg((900, 600)))
     await dispatch(ctx.client, ev)
-    assert OWNER not in ctx.app.pending and ev.out == []  # no "thumbnail saved" for the global one
+    assert OWNER not in ctx.app.pending and ev.out == []  # the format's panel is shown again, no "saved for your auto format"
     stored = await ctx.db.get_format_thumb(OWNER, i)
-    assert stored[:2] == b"\xff\xd8" and await ctx.db.get_thumb(OWNER) is None  # the format's, not the user's default
+    assert stored[:2] == b"\xff\xd8" and await autofmt(ctx) is None  # the photo went to this format, no "Default" auto format was made
     chat, text, kw = ctx.client.edited[-1]
     assert kw["message"] == 800 and "Thumbnail saved" in text and "✅ saved" in text and f"fm:thd:{i}" in data_of(kw["buttons"])
 
     cb = await click(ctx, OWNER, f"fm:thd:{i}")
     assert cb.toasts == ["Thumbnail deleted."] and await ctx.db.get_format_thumb(OWNER, i) is None
-    assert "your default thumbnail" in cb.edits[-1][0]
+    assert panels.THUMB_NONE in cb.edits[-1][0]
 
 
-async def test_a_photo_without_a_pending_format_prompt_is_still_the_global_thumbnail(ctx):
-    await make_format(ctx)
+async def test_a_photo_without_a_pending_format_prompt_is_the_thumbnail_of_the_auto_format(ctx):
+    manual = await make_format(ctx)
     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 (await ctx.db.get_thumb(OWNER)) is not None
+    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
 
 
 async def test_deleting_a_format_asks_first(ctx):
@@ -240,13 +318,16 @@ async def test_deleting_a_format_asks_first(ctx):
     assert "🗂 One Piece" in cb.edits[-1][0]
     cb = await click(ctx, OWNER, f"fm:ok:{i}")
     assert await ctx.db.get_format(OWNER, i) is None
-    assert "FORMATS" in cb.edits[-1][0] and cb.toasts == ["Deleted One Piece."]
+    assert "MANUAL FORMATS" in cb.edits[-1][0] and cb.toasts == ["Deleted One Piece."]  # back to the list it was in
 
 
-async def test_buttons_of_a_deleted_format_say_so_and_show_the_list(ctx):
+async def test_buttons_of_a_deleted_format_say_so_and_show_the_chooser(ctx):
     fmt = await make_format(ctx)
     await ctx.db.delete_format(OWNER, fmt["id"])
-    for data in (f"fm:v:{fmt['id']}", f"fm:in:{fmt['id']}:title", f"fm:th:{fmt['id']}", f"fm:del:{fmt['id']}", f"fm:ok:{fmt['id']}"):
+    for data in (
+        f"fm:v:{fmt['id']}", f"fm:in:{fmt['id']}:title", f"fm:th:{fmt['id']}", f"fm:del:{fmt['id']}", f"fm:ok:{fmt['id']}",
+        f"fm:dm:{fmt['id']}", f"fm:cp:{fmt['id']}", f"fm:use:{fmt['id']}",
+    ):
         cb = await click(ctx, OWNER, data)
         assert cb.alerts == ["That format no longer exists."] and "FORMATS" in cb.edits[-1][0], data
     assert OWNER not in ctx.app.pending
@@ -262,50 +343,58 @@ async def test_typing_into_a_prompt_for_a_deleted_format_is_handled(ctx):
 
 async def test_formats_belong_to_one_user(ctx):
     mine = await make_format(ctx, "Mine")
-    cb = await click(ctx, ADMIN_CFG, f"fm:v:{mine['id']}")
-    assert cb.alerts == ["That format no longer exists."]
-    cb = await click(ctx, ADMIN_CFG, f"fm:ok:{mine['id']}")
-    assert await ctx.db.get_format(OWNER, mine["id"]) is not None
+    auto = await make_format(ctx, "Auto", kind="auto")
+    for fid in (mine["id"], auto["id"]):
+        cb = await click(ctx, ADMIN_CFG, f"fm:v:{fid}")
+        assert cb.alerts == ["That format no longer exists."]
+        for action in ("ok", "dm", "cp", "use"):
+            await click(ctx, ADMIN_CFG, f"fm:{action}:{fid}")
+        assert await ctx.db.get_format(OWNER, fid) is not None
+    assert await ctx.db.count_formats(OWNER) == 2 and await ctx.db.count_formats(ADMIN_CFG) == 0
     ev = await say(ctx, ADMIN_CFG, "/formats")
-    assert "no formats yet" in ev.texts[0]
+    assert flat_buttons(ev.out[0][1])[:2] == [("🤖 Auto rename (0/12)", "fm:l:auto"), ("✋ Manual rename (0/12)", "fm:l:manual")]
     ev = await say(ctx, ADMIN_CFG, "/rename")
-    assert "no saved formats" in ev.texts[0]
+    assert "no manual formats yet" in ev.texts[0]
 
 
 async def test_any_other_tap_abandons_an_open_prompt(ctx):
     fmt = await make_format(ctx)
     await click(ctx, OWNER, f"fm:in:{fmt['id']}:title")
-    await click(ctx, OWNER, "fm:new")
+    await click(ctx, OWNER, "fm:new:manual")
     assert ctx.app.pending[OWNER].kind == "fmt:new"
     await click(ctx, OWNER, f"fm:v:{fmt['id']}")
     assert OWNER not in ctx.app.pending
 
 
 # ---------------------------------------------------------------------------
-# /rename: pick a format, send one file
+# /rename: pick a manual format, send one file
 # ---------------------------------------------------------------------------
 
 
-async def test_rename_without_formats_points_to_creating_one(ctx):
+async def test_rename_without_manual_formats_points_to_creating_one(ctx):
     ev = await say(ctx, OWNER, "/rename")
-    assert "no saved formats" in ev.texts[0] and "fm:new" in data_of(ev.out[0][1])
+    assert "no manual formats yet" in ev.texts[0] and "fm:new:manual" in data_of(ev.out[0][1])
     ev = await say(ctx, OWNER, "/rename New Name", reply=FakeMessage("x", mid=3))  # the old reply-with-a-name form is gone
-    assert "no saved formats" in ev.texts[0] and not ctx.app.queue.jobs
+    assert "no manual formats yet" in ev.texts[0] and not ctx.app.queue.jobs
+    await make_format(ctx, "Auto One", kind="auto")  # an auto format is not for /rename
+    ev = await say(ctx, OWNER, "/rename")
+    assert "no manual formats yet" in ev.texts[0]
 
 
-async def test_rename_offers_the_saved_formats_by_name(ctx):
+async def test_rename_offers_the_saved_manual_formats_by_name(ctx):
     a, b = await make_format(ctx, "One Piece"), await make_format(ctx, "Dragon Ball")
+    auto = await make_format(ctx, "Auto One", kind="auto")
     ev = await say(ctx, OWNER, "/rename")
-    assert "Choose the format" in ev.texts[0]
+    assert "Choose the manual format" in ev.texts[0]
     data = data_of(ev.out[0][1])
-    assert f"rn:p:{a['id']}" in data and f"rn:p:{b['id']}" in data and "m:formats" in data
-    labels = [btn.text for row in ev.out[0][1] for btn in row]
-    assert "One Piece" in labels and "Dragon Ball" in labels
+    assert f"rn:p:{a['id']}" in data and f"rn:p:{b['id']}" in data and "fm:l:manual" in data
+    assert f"rn:p:{auto['id']}" not in data and "Auto One" not in labels_of(ev.out[0][1])  # that one is chosen in the /start menu
+    assert "One Piece" in labels_of(ev.out[0][1]) and "Dragon Ball" in labels_of(ev.out[0][1])
     assert not ctx.app.queue.jobs and ctx.app._mode(OWNER) is None  # nothing is armed until a format is chosen
 
 
 async def test_choosing_a_format_then_sending_a_file_renames_it_with_that_format(ctx):
-    await ctx.db.update_settings(OWNER, template="DEFAULT {title}")
+    await make_format(ctx, "Auto One", kind="auto", template="DEFAULT {title}")
     fmt = await make_format(ctx, meta={"title": "One Piece"})
     cb = await click(ctx, OWNER, f"rn:p:{fmt['id']}")
     assert cb.toasts == ["Format: One Piece"] and ctx.app._mode(OWNER, "rename") is not None
@@ -315,7 +404,7 @@ async def test_choosing_a_format_then_sending_a_file_renames_it_with_that_format
 
     ev = await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
     (job,) = ctx.app.queue.jobs.values()
-    assert job.new_name == "One Piece - E1147.mkv"  # the format's template, not the default one
+    assert job.new_name == "One Piece - E1147.mkv"  # the manual format's template, not the auto format's
     assert job.fmt["id"] == fmt["id"] and job.fmt["meta"]["title"] == "One Piece" and job.order == 50
     assert "Queued" in ev.texts[0] and "🗂 Format: <b>One Piece</b>" in ev.texts[0] and "One Piece - E1147.mkv" in ev.texts[0]
     assert ctx.app._mode(OWNER) is None  # it was for one file
@@ -331,6 +420,7 @@ async def test_other_settings_still_come_from_the_users_own_settings(ctx):
 
 
 async def test_the_next_file_needs_rename_again(ctx):
+    auto = await make_format(ctx, "Auto One", kind="auto", template="Auto - E{episode}")
     fmt = await make_format(ctx)
     await click(ctx, OWNER, f"rn:p:{fmt['id']}")
     await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
@@ -341,16 +431,17 @@ async def test_the_next_file_needs_rename_again(ctx):
     assert ev.out == []
     assert [j.file_name for j in ctx.app.queue.jobs.values()] == [ONE_PIECE]
 
-    # once the short grace period is over, files are renamed with the normal settings as usual
+    # once the short grace period is over, files are renamed with the auto format as usual
     ctx.app._recent[OWNER][1] -= appmod.ONE_SHOT_GRACE + 1
     ev = await send_doc(ctx, OWNER, "1150 - One Piece [Dual] 720p.mkv", mid=53)
-    assert "Queued" in ev.texts[0] and "Format" not in ev.texts[0]
+    assert "Queued" in ev.texts[0] and "🗂 Auto format: <b>Auto One</b>" in ev.texts[0] and "Auto - E1150.mkv" in ev.texts[0]
     assert len(ctx.app.queue.jobs) == 2
 
     # and choosing a format again renames the next one with it
     await click(ctx, OWNER, f"rn:p:{fmt['id']}")
     ev = await send_doc(ctx, OWNER, "1151 - One Piece [Dual] 720p.mkv", mid=54)
     assert "🗂 Format: <b>One Piece</b>" in ev.texts[0] and len(ctx.app.queue.jobs) == 3
+    assert auto["id"] != fmt["id"]
 
 
 async def test_a_forwarded_batch_gives_the_format_to_exactly_one_file(ctx):
@@ -370,7 +461,7 @@ async def test_the_chosen_format_is_forgotten_after_the_wait(ctx):
     ctx.app.modes[OWNER].expires = time.time() - 1
     ev = await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
     (job,) = ctx.app.queue.jobs.values()
-    assert job.fmt is None and "Format" not in ev.texts[0]  # a normal auto-rename
+    assert job.fmt is None and "Format" not in ev.texts[0]  # a normal auto-rename (the user has no auto format)
     assert ctx.app._mode(OWNER) is None
 
 
@@ -396,7 +487,16 @@ async def test_choosing_a_format_that_is_gone_or_not_yours(ctx):
     assert cb.alerts == ["That format no longer exists."] and ctx.app._mode(ADMIN_CFG) is None
     await ctx.db.delete_format(OWNER, fmt["id"])
     cb = await click(ctx, OWNER, f"rn:p:{fmt['id']}")
-    assert cb.alerts == ["That format no longer exists."] and "no saved formats" in cb.edits[-1][0]
+    assert cb.alerts == ["That format no longer exists."] and "no manual formats yet" in cb.edits[-1][0]
+
+
+async def test_an_auto_format_cannot_be_chosen_for_rename(ctx):
+    auto = await make_format(ctx, "Auto One", kind="auto")
+    cb = await click(ctx, OWNER, f"rn:p:{auto['id']}")  # a stale or made-up button: the picker never offers it
+    assert cb.alerts == ["That format no longer exists."] and ctx.app._mode(OWNER) is None
+    await send_doc(ctx, OWNER, ONE_PIECE, mid=50)
+    (job,) = ctx.app.queue.jobs.values()
+    assert job.fmt["id"] == auto["id"]  # the file goes through the auto format, as any file does
 
 
 async def test_one_users_chosen_format_does_not_affect_another(ctx):
@@ -412,7 +512,7 @@ async def test_change_format_and_stop_buttons(ctx):
     a, b = await make_format(ctx, "One Piece"), await make_format(ctx, "Dragon Ball")
     await click(ctx, OWNER, f"rn:p:{a['id']}")
     cb = await click(ctx, OWNER, "rn:menu")
-    assert "Choose the format" in cb.edits[-1][0] and ctx.app._mode(OWNER) is None
+    assert "Choose the manual format" in cb.edits[-1][0] and ctx.app._mode(OWNER) is None
     await click(ctx, OWNER, f"rn:p:{b['id']}")
     assert ctx.app.modes[OWNER].data["fid"] == b["id"]
     cb = await click(ctx, OWNER, "rn:stop")
@@ -452,27 +552,33 @@ async def test_start_and_the_rename_picker_close_an_open_text_prompt(ctx):
     assert OWNER not in ctx.app.pending
 
 
-def test_the_format_screens_fit_in_a_caption_even_with_the_longest_values():
+@pytest.mark.parametrize("kind", KINDS)
+def test_the_format_screens_fit_in_a_caption_even_with_the_longest_values(kind):
     from .test_panels import CAPTION_LIMIT, visible
 
     longest = ["klingon-language-tag-x"] * 12
     fmt = {
-        "id": 12, "name": "N" * 30, "has_thumb": True, "template": "T" * 200, "caption": "C" * 800,
+        "id": 12, "name": "N" * 30, "kind": kind, "has_thumb": True, "template": "T" * 200, "caption": "C" * 800,
         "meta": {k: "M" * 200 for k in ("title", "author", "artist", "audio", "subtitle", "video")},
         "keep_audio": longest, "keep_subtitle": longest,
     }
     formats = [dict(fmt, id=i, name="F" * 30) for i in range(12)]
+    other = dict(fmt, kind="manual" if kind == "auto" else "auto", id=13)
     for name, (text, rows) in {
-        "view": panels.format_view(fmt), "view_inline": panels.format_view(fmt, share_inline=True),
-        "menu": panels.formats_menu(formats, 12), "delete": panels.format_delete_confirm(fmt),
+        "view": panels.format_view(fmt), "view_active": panels.format_view(fmt, active=True),
+        "view_inline": panels.format_view(fmt, share_inline=True),
+        "menu": panels.formats_menu(formats, 12, kind, 3), "delete": panels.format_delete_confirm(fmt),
+        "chooser": panels.formats_home(12, 12, 12), "auto_menu": panels.auto_menu(formats, 3, 12),
         "ready": panels.rename_ready(fmt, 10), "picker": panels.rename_picker(formats),
+        "copied": panels.format_copied(fmt, other), "metadata_applied": (panels.format_metadata_applied(fmt), []),
         "shared": panels.shared_format(fmt, "T" * 16), "shared_mine": panels.shared_format(fmt, "T" * 16, mine=True),
         "added": panels.shared_added(fmt), "card": (panels.share_card(fmt)[2], []),
-        **{f"prompt_{k}": panels.format_prompt(k, 12) for k in panels.FORMAT_PROMPTS},
+        **{f"prompt_{k}": panels.format_prompt(k, 12) for k in panels.FORMAT_PROMPTS if k != "new"},
+        "prompt_new": panels.format_prompt("new", 0, kind),
     }.items():
         assert len(visible(text)) <= CAPTION_LIMIT, (name, len(visible(text)))
         assert text.count("<b>") == text.count("</b>") and text.count("<code>") == text.count("</code>"), name
         for row in rows:
-            assert 1 <= len(row) <= 3, name
+            assert 1 <= len(row) <= 4, name
             for label, data in row:
                 assert label.strip() and len(label) <= 32 and 0 < len(data.encode()) <= 64, (name, label, data)

tests/test_panels.py

@@ -15,8 +15,8 @@ from bot.utils import code_each
 from .tgfakes import button_rows, variables_line
 
 CAPTION_LIMIT = 1000  # Telegram allows 1024 for a caption; keep a margin
-TEMPLATE_LIST = "{title} {season} {episode} {quality} {year} {codec} {filename} {ext}"
-CAPTION_LIST = "{filename} {original} {title} {season} {episode} {quality} {year} {codec} {size} {duration}"
+TEMPLATE_LIST = "{title} {season} {episode} {1episode} {2episode} {3episode} {quality} {year} {codec} {filename} {ext}"
+CAPTION_LIST = "{filename} {original} {title} {season} {episode} {1episode} {2episode} {3episode} {quality} {year} {codec} {size} {duration}"
 
 
 def visible(text: str) -> str:
@@ -33,38 +33,81 @@ def worst_case():
     longest = sorted(LANGUAGES, key=len, reverse=True)[:12]
     return settings(
         mode="caption", file_type="document", metadata_on=True,
-        template="W" * 200, caption="C" * 800, remove_words=["R" * 60] * 50,
+        remove_words=["R" * 60] * 50,
         meta={k: "M" * 200 for k in DEFAULT_SETTINGS["meta"]},
         keep_audio=list(longest), keep_subtitle=list(longest), target_channel=-1001234567890123,
     )
 
 
-def every_panel(s, has_thumb=True):
+def sample_format(**over):
+    fmt = {"id": 12, "name": "One Piece", "kind": "manual", "has_thumb": False, "template": "[S{season}E{episode}] {title}",
+           "caption": "<b>{filename}</b>", "meta": {k: "" for k in ("title", "author", "artist", "audio", "subtitle", "video")}, "keep_audio": [], "keep_subtitle": []}
+    fmt.update(over)
+    return fmt
+
+
+def worst_format(fid=12, kind="auto", **over):
+    longest = sorted(LANGUAGES, key=len, reverse=True)[:12]
+    fmt = sample_format(
+        id=fid, kind=kind, name="N" * 30, has_thumb=True, template="W" * 200, caption="C" * 800,
+        meta={k: "M" * 200 for k in DEFAULT_SETTINGS["meta"]}, keep_audio=list(longest), keep_subtitle=list(longest),
+    )
+    fmt.update(over)
+    return fmt
+
+
+def every_panel(s, has_thumb=True, 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)]
     out = {
-        "home_owner": panels.home(s, owner=True),
-        "home_user": panels.home(s, owner=False),
-        "rename": panels.rename(s),
-        "cap": panels.caption(s, has_thumb),
+        "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),
         "help": panels.help_panel(),
         "metahelp": panels.metadata_help(),
         "admin": panels.admin(1, list(range(1000, 1030)), 3, 4, -1001234567890),
+        "formats_home": panels.formats_home(12, 12, 12),
+        "auto_menu": panels.auto_menu(formats, 3, 12),
+        "auto_menu_empty": panels.auto_menu([], 0, 12),
+        "auto_list": panels.formats_menu(formats, 12, "auto", 3),
+        "manual_list": panels.formats_menu(manual, 12, "manual"),
+        "manual_list_empty": panels.formats_menu([], 12, "manual"),
+        "auto_format": panels.format_view(formats[2], active=False),
+        "auto_format_in_use": panels.format_view(formats[2], active=True, share_inline=True),
+        "manual_format": panels.format_view(manual[0], share_inline=True),
+        "copied": panels.format_copied(formats[0], manual[0]),
+        "delete": panels.format_delete_confirm(formats[0]),
+        "picker": panels.rename_picker(manual),
+        "picker_empty": panels.rename_picker([]),
+        "ready": panels.rename_ready(manual[0], 10),
+        "shared": panels.shared_format(formats[0], "tok"),
+        "shared_mine": panels.shared_format(manual[0], "tok", mine=True),
+        "shared_added": panels.shared_added(manual[0]),
     }
     out.update({f"prompt_{k}": panels.input_prompt(k, BACK[k]) for k in panels.PROMPTS})
+    out.update({f"format_prompt_{k}": panels.format_prompt(k, 12) for k in panels.FORMAT_PROMPTS if k != "new"})
+    out["format_prompt_new"] = panels.format_prompt("new", 0, "auto")
     return out
 
 
-@pytest.mark.parametrize("s", [settings(), worst_case()], ids=["defaults", "worst-case"])
-def test_every_panel_fits_in_a_photo_caption(s):
-    for name, (text, _rows) in every_panel(s).items():
+CASES = [(settings(), None), (worst_case(), None), (worst_case(), worst_format())]
+CASE_IDS = ["defaults", "worst-case settings", "worst-case settings and format"]
+
+
+@pytest.mark.parametrize("s, auto", CASES, ids=CASE_IDS)
+def test_every_panel_fits_in_a_photo_caption(s, auto):
+    for name, (text, _rows) in every_panel(s, auto=auto).items():
         assert len(visible(text)) <= CAPTION_LIMIT, f"{name} is {len(visible(text))} characters"
 
 
-@pytest.mark.parametrize("s", [settings(), worst_case()], ids=["defaults", "worst-case"])
-def test_callback_data_is_short_unique_per_panel_and_labels_are_present(s):
-    for name, (_text, rows) in every_panel(s).items():
+@pytest.mark.parametrize("s, auto", CASES, ids=CASE_IDS)
+def test_callback_data_is_short_unique_per_panel_and_labels_are_present(s, auto):
+    for name, (_text, rows) in every_panel(s, auto=auto).items():
         seen = set()
         for row in rows:
             assert 1 <= len(row) <= 4, name
@@ -76,7 +119,7 @@ def test_callback_data_is_short_unique_per_panel_and_labels_are_present(s):
 
 
 def test_every_panel_html_is_balanced():
-    for name, (text, _rows) in every_panel(worst_case()).items():
+    for name, (text, _rows) in every_panel(worst_case(), auto=worst_format()).items():
         for tag in ("b", "code", "i"):
             assert text.count(f"<{tag}>") == text.count(f"</{tag}>"), (name, tag)
 
@@ -85,7 +128,7 @@ def test_every_panel_html_is_balanced():
     ("template prompt", panels.PROMPTS["template"], TEMPLATE_LIST),
     ("caption prompt", panels.PROMPTS["caption"], CAPTION_LIST),
     ("help panel", panels.help_panel()[0], TEMPLATE_LIST),
-    ("caption panel", panels.caption(settings(), True)[0], CAPTION_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.
@@ -100,13 +143,6 @@ def test_code_each_makes_one_escaped_block_per_item():
     assert code_each([]) == ""
 
 
-def sample_format(**over):
-    fmt = {"id": 12, "name": "One Piece", "has_thumb": False, "template": "[S{season}E{episode}] {title}",
-           "caption": "<b>{filename}</b>", "meta": {k: "" for k in ("title", "author", "artist", "audio", "subtitle", "video")}, "keep_audio": [], "keep_subtitle": []}
-    fmt.update(over)
-    return fmt
-
-
 def test_the_share_button_is_the_chat_picker_or_the_plain_button_that_explains():
     fmt = sample_format()
     on = [d for row in panels.format_view(fmt, share_inline=True)[1] for _l, d in row]
@@ -159,6 +195,10 @@ def test_navigation_always_offers_a_way_out():
         data = [d for row in rows for _l, d in row]
         if name.startswith("prompt_"):
             assert any(d.startswith("in:cancel:") for d in data), name
+        elif name.startswith("format_prompt_"):
+            assert any(d.startswith(("fm:cx:", "fm:l:")) for d in data), name
+        elif name in ("delete", "ready"):  # a choice and a wait for a file: they have their own way out (Keep it, Stop)
+            assert any(d.startswith(("fm:v:", "rn:stop")) for d in data), name
         else:
             assert "x:close" in data, name
 
@@ -171,6 +211,18 @@ def test_home_shows_admin_button_only_to_the_owner():
         assert expected in user
 
 
+def test_home_metadata_line_says_what_the_auto_format_in_use_will_do():
+    def line(s, auto=None):
+        return re.search(r"Metadata: (ON|OFF)", visible(panels.home(s, owner=False, auto=auto)[0])).group(1)
+
+    assert line(settings(metadata_on=False)) == "OFF" and line(settings(metadata_on=True)) == "ON"  # no auto format: the switch
+    plain = sample_format(kind="auto")
+    own = sample_format(kind="auto", meta={**plain["meta"], "title": "T"})
+    assert line(settings(metadata_on=False), own) == "ON"  # the format carries metadata of its own: the switch is not asked
+    assert line(settings(metadata_on=False), plain) == "OFF" and line(settings(metadata_on=True), plain) == "ON"  # none: the default decides
+    assert line(settings(metadata_on=False), sample_format(kind="auto", keep_audio=["english"])) == "ON"
+
+
 def test_active_choices_get_a_checkmark():
     def labels(panel):
         return {data: label for row in panel[1] for label, data in row}
@@ -211,9 +263,11 @@ def test_fmt_tokens():
 
 
 def test_html_in_user_values_is_escaped():
-    s = settings(template="<b>{title}</b> & co", meta={**DEFAULT_SETTINGS["meta"], "title": "<i>x</i>"})
-    assert "<b>{title}</b>" not in panels.rename(s)[0]
-    assert "&lt;b&gt;" in panels.rename(s)[0]
+    s = settings(meta={**DEFAULT_SETTINGS["meta"], "title": "<i>x</i>"})
+    auto = sample_format(kind="auto", name="<u>Mine</u>", template="<b>{title}</b> & co")
+    assert "<b>{title}</b>" not in panels.rename(s, auto)[0]
+    assert "&lt;b&gt;" in panels.rename(s, auto)[0] and "<u>Mine</u>" not in panels.rename(s, auto)[0]
+    assert "<b>{title}</b>" not in panels.home(s, owner=True, auto=auto)[0] and "<u>" not in panels.home(s, owner=True, auto=auto)[0]
     assert "<i>x</i>" not in panels.metadata(s)[0]
 
 

tests/test_parser.py

@@ -5,7 +5,9 @@ from bot.parser import (
     apply_remove_words,
     compute_new_name,
     finalize_name,
+    build_values,
     missing_variables,
+    padded_episode,
     parse_caption,
     parse_info,
     render_template,
@@ -279,3 +281,74 @@ def test_missing_variables_only_reports_holes_outside_bracket_groups():
     assert missing_variables("{title} ({year})", info) == []
     assert missing_variables("{title} {nope}", info) == []
     assert missing_variables("One Piece - E{episode}", parse_info("1147 - One Piece 720p.mkv")) == []
+
+
+# ---------------------------------------------------------------------------
+# {1episode} {2episode} {3episode}: the episode with zeros in front
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "detected, zeros, expected",
+    [
+        ("4", 1, "04"), ("04", 1, "04"), ("14", 1, "14"), ("100", 1, "100"), ("004", 1, "004"),  # {1episode}: at least 2 digits
+        ("4", 2, "004"), ("04", 2, "004"), ("004", 2, "004"), ("005", 2, "005"), ("14", 2, "014"), ("1147", 2, "1147"),
+        ("4", 3, "0004"), ("04", 3, "0004"), ("004", 3, "0004"), ("12", 3, "0012"),  # {3episode}: at least 4 digits
+        ("321", 3, "0321"), ("1321", 3, "1321"), ("1147", 3, "1147"), ("12345", 3, "12345"),  # wide enough: no zero is added
+        ("", 1, ""), ("", 3, ""),  # no episode found: nothing to pad
+    ],
+)
+def test_padded_episode(detected, zeros, expected):
+    assert padded_episode(detected, zeros) == expected
+
+
+@pytest.mark.parametrize("written", ["E4", "E04", "E004", "Episode 4", "S01E4", "S01E004"])
+def test_the_padded_variables_do_not_depend_on_how_the_episode_was_written(written):
+    info = parse_info(f"Show {written} 720p.mkv")
+    values = build_values(info, "Show", ".mkv")
+    assert [values[name] for name in ("episode", "1episode", "2episode", "3episode")] == ["04", "04", "004", "0004"]
+    assert "4episode" not in values  # three padded variables: up to four digits
+
+
+def test_the_padded_variables_in_a_template():
+    name, _ = compute_new_name(
+        template="{title} - {1episode} - {2episode} - {3episode}", mode="filename",
+        original_name="One Piece - 4 [1080p].mkv", original_ext=".mkv",
+    )
+    assert name == "One Piece - 04 - 004 - 0004.mkv"
+    name, _ = compute_new_name(
+        template="{title} {2episode}", mode="filename", original_name="1147 - One Piece [Dual] 720p.mkv", original_ext=".mkv",
+    )
+    assert name == "One Piece 1147.mkv"  # a number that is wide enough keeps its digits
+
+
+@pytest.mark.parametrize("original, expected", [
+    ("One Piece - 1321 [1080p].mkv", "One Piece 1321.mkv"),  # four digits already: no zero is added
+    ("One Piece - 321 [1080p].mkv", "One Piece 0321.mkv"),  # three digits: one zero
+    ("One Piece - 21 [1080p].mkv", "One Piece 0021.mkv"),
+    ("One Piece - 1 [1080p].mkv", "One Piece 0001.mkv"),
+    ("1321 - One Piece [Dual] 720p.mkv", "One Piece 1321.mkv"),
+    ("One Piece S01E0321 720p.mkv", "One Piece 0321.mkv"),  # zeros that were already there are not counted twice
+])
+def test_third_padded_episode_is_four_digits_wide(original, expected):
+    name, _ = compute_new_name(template="{title} {3episode}", mode="filename", original_name=original, original_ext=".mkv")
+    assert name == expected
+
+
+def test_a_fourth_padded_variable_does_not_exist():
+    values = build_values(parse_info("One Piece - 4 [1080p].mkv"), "One Piece", ".mkv")
+    assert "4episode" not in values
+    name, _ = compute_new_name(
+        template="{title} {4episode}", mode="filename", original_name="One Piece - 4 [1080p].mkv", original_ext=".mkv"
+    )
+    assert name == "One Piece {4episode}.mkv"  # an unknown variable is left as plain text
+
+
+def test_without_an_episode_a_group_with_a_padded_variable_goes_away():
+    info = parse_info("Plain Movie.mkv")
+    values = build_values(info, "Plain Movie", ".mkv")
+    assert values["1episode"] == values["3episode"] == ""
+    assert render_template("{title} [E{3episode}]", values) == "Plain Movie"
+    assert missing_variables("{title} E{2episode}", info) == ["2episode"]  # a bare one leaves a hole in the name
+    assert missing_variables("{title} [E{2episode}] {episode} {3episode}", info) == ["episode", "3episode"]
+    assert missing_variables("{title} E{2episode}", parse_info("One Piece - 05.mkv")) == []

tests/test_pipeline.py

@@ -168,10 +168,20 @@ async def test_forced_video_for_non_video_falls_back_to_document(env, tmp_path):
     assert kw["thumb"] is None
 
 
+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)
+    if changes:
+        await env.db.update_format(42, fmt["id"], **changes)
+    if thumb:
+        await env.db.set_format_thumb(42, fmt["id"], thumb)
+    return await env.db.get_format(42, fmt["id"])
+
+
 @needs_ffmpeg
 async def test_custom_thumbnail_wins_over_generated(env):
-    await env.db.set_thumb(42, b"\xff\xd8custom")
     client, renamer, job = make(env)
+    job.fmt = await make_auto(env, thumb=b"\xff\xd8custom")
     await renamer.process(job)
     assert client.sent[0][2]["thumb"] == b"\xff\xd8custom"
 
@@ -321,9 +331,9 @@ async def make_fmt(env, name="One Piece", **changes):
 
 @needs_ffmpeg
 async def test_a_format_brings_its_own_metadata_tracks_and_thumbnail(env):
-    # the global metadata is off and has a different title: the format must not depend on either
-    await env.db.update_settings(42, metadata_on=False, meta={"title": "GLOBAL"}, keep_audio=["hindi"])
-    await env.db.set_thumb(42, b"\xff\xd8global")
+    # the default metadata is off and has a different title: a manual format must not depend on either
+    await env.db.update_settings(42, metadata_on=False, meta={"title": "DEFAULT"}, keep_audio=["hindi"])
+    await make_auto(env, thumb=b"\xff\xd8auto")  # nor on the auto format
     fmt = await make_fmt(env, meta={"title": "One Piece", "audio": "{lang}"}, keep_audio=["english", "japanese"], keep_subtitle=["2"])
     await env.db.set_format_thumb(42, fmt["id"], b"\xff\xd8format")
     fmt = await env.db.get_format(42, fmt["id"])
@@ -341,19 +351,19 @@ async def test_a_format_brings_its_own_metadata_tracks_and_thumbnail(env):
 
 
 @needs_ffmpeg
-async def test_a_format_without_a_thumbnail_uses_the_users_default_one(env):
-    await env.db.set_thumb(42, b"\xff\xd8global")
+async def test_a_format_without_a_thumbnail_gets_a_frame_of_the_video(env):
+    await make_auto(env, thumb=b"\xff\xd8auto")  # another format's thumbnail is not borrowed
     fmt = await make_fmt(env)
     client, renamer, job = make(env)
     job.fmt = fmt
     await renamer.process(job)
     (_t, _f, kw), = client.sent
-    assert kw["thumb"] == b"\xff\xd8global"
+    assert kw["thumb"][:2] == b"\xff\xd8" and kw["thumb"] != b"\xff\xd8auto"  # cut out of the video
 
 
 @needs_ffmpeg
-async def test_a_format_that_sets_no_metadata_leaves_the_file_untouched_even_if_global_metadata_is_on(env):
-    await env.db.update_settings(42, metadata_on=True, meta={"title": "GLOBAL"}, keep_audio=["english"])
+async def test_a_manual_format_that_sets_no_metadata_leaves_the_file_untouched_even_if_default_metadata_is_on(env):
+    await env.db.update_settings(42, metadata_on=True, meta={"title": "DEFAULT"}, keep_audio=["english"])
     fmt = await make_fmt(env)
     client, renamer, job = make(env)
     job.fmt = fmt
@@ -362,9 +372,39 @@ async def test_a_format_that_sets_no_metadata_leaves_the_file_untouched_even_if_
     assert job.state == "done"
 
 
+@needs_ffmpeg
+async def test_an_auto_format_without_metadata_uses_the_default_metadata_while_it_is_on(env):
+    await env.db.update_settings(42, metadata_on=True, meta={"title": "DEFAULT TITLE"})
+    client, renamer, job = make(env)
+    job.fmt = await make_auto(env)  # sets no metadata of its own
+    await renamer.process(job)
+    assert (await probe(client.uploads[0])).tags.get("title") == "DEFAULT TITLE"
+
+    await env.db.update_settings(42, metadata_on=False)  # switched off: the file is left alone
+    client, renamer, job = make(env)
+    job.fmt = await make_auto(env)
+    await renamer.process(job)
+    assert client.uploads[0].read_bytes() == (env.media_dir / "sample.mkv").read_bytes()
+
+
+@needs_ffmpeg
+async def test_an_auto_format_with_metadata_of_its_own_ignores_the_default_metadata(env):
+    await env.db.update_settings(42, metadata_on=True, meta={"title": "DEFAULT TITLE"})
+    client, renamer, job = make(env)
+    job.fmt = await make_auto(env, meta={"title": "OWN TITLE"})
+    await renamer.process(job)
+    assert (await probe(client.uploads[0])).tags.get("title") == "OWN TITLE"
+
+    await env.db.update_settings(42, metadata_on=False)  # its own metadata applies whatever the switch says
+    client, renamer, job = make(env)
+    job.fmt = await make_auto(env)
+    await renamer.process(job)
+    assert (await probe(client.uploads[0])).tags.get("title") == "OWN TITLE"
+
+
 @needs_ffmpeg
 async def test_everything_else_still_comes_from_the_users_settings(env):
-    await env.db.update_settings(42, file_type="document", caption="<b>{filename}</b> by me", target_channel=-100777)
+    await env.db.update_settings(42, file_type="document", target_channel=-100777)
     fmt = await make_fmt(env, meta={"title": "T"})
     client, renamer, job = make(env)
     job.fmt = fmt
@@ -372,14 +412,14 @@ async def test_everything_else_still_comes_from_the_users_settings(env):
     await renamer.process(job)
     (target, _f, kw), = client.sent
     assert target == -100777 and kw["force_document"] is True  # the file type and the channel are still the user's
-    assert kw["caption"] == "<b>One Piece - E5</b>"  # the caption is not: this format has none, so it is the new name in bold
+    assert kw["caption"] == "<b>One Piece - E5</b>"  # the caption is the format's: it has none, so it is the new name in bold
 
 
 @needs_ffmpeg
 async def test_a_format_sends_its_own_caption(env):
     from bot.utils import human_size
 
-    await env.db.update_settings(42, caption="<i>THE USER'S CAPTION {filename}</i>")
+    await make_auto(env, caption="<i>THE AUTO FORMAT'S CAPTION {filename}</i>")  # another format's caption is not borrowed
     fmt = await make_fmt(env, caption="<b>{filename}</b> · {original} · {size}")
     client, renamer, job = make(env)
     job.fmt = fmt
@@ -391,8 +431,8 @@ async def test_a_format_sends_its_own_caption(env):
 
 
 @needs_ffmpeg
-async def test_a_format_without_a_caption_sends_the_new_name_in_bold_not_the_users_caption(env):
-    await env.db.update_settings(42, caption="<i>THE USER'S CAPTION {filename}</i>")
+async def test_a_format_without_a_caption_sends_the_new_name_in_bold(env):
+    await make_auto(env, caption="<i>THE AUTO FORMAT'S CAPTION {filename}</i>")
     fmt = await make_fmt(env)
     client, renamer, job = make(env)
     job.fmt = fmt
@@ -402,24 +442,36 @@ async def test_a_format_without_a_caption_sends_the_new_name_in_bold_not_the_use
 
 
 @needs_ffmpeg
-async def test_a_rename_without_a_format_still_uses_the_users_caption(env):
-    await env.db.update_settings(42, caption="<i>{filename}</i> ({quality})")
-    await env.db.create_format(42, "Unused", template="X")  # having formats changes nothing for the normal renames
+async def test_an_auto_rename_uses_the_caption_of_its_auto_format(env):
+    await env.db.create_format(42, "Unused", template="X")  # a manual format changes nothing for the auto renames
     client, renamer, job = make(env)
+    job.fmt = await make_auto(env, caption="<i>{filename}</i> ({quality})")
     await renamer.process(job)
     assert client.sent[0][2]["caption"] == "<i>[S01E05] Tokyo Revengers [1080p]</i> (1080p)"
 
 
 @needs_ffmpeg
-async def test_a_format_deleted_while_queued_falls_back_to_the_users_thumbnail_and_still_finishes(env):
-    await env.db.set_thumb(42, b"\xff\xd8global")
+async def test_an_auto_rename_without_any_format_uses_the_built_in_defaults(env):
+    client, renamer, job = make(env)
+    assert job.fmt is None
+    await renamer.process(job)
+    (_t, _f, kw), = client.sent
+    assert kw["caption"] == "<b>[S01E05] Tokyo Revengers [1080p]</b>"  # the new name in bold
+    assert kw["thumb"][:2] == b"\xff\xd8"  # a frame of the video
+    assert client.uploads[0].read_bytes() == (env.media_dir / "sample.mkv").read_bytes()
+    assert await env.db.list_formats(42) == []  # nothing was made for it
+
+
+@needs_ffmpeg
+async def test_a_format_deleted_while_queued_still_finishes_with_its_snapshot(env):
     fmt = await make_fmt(env, meta={"title": "One Piece"})
+    await env.db.set_format_thumb(42, fmt["id"], b"\xff\xd8gone")
     await env.db.delete_format(42, fmt["id"])
     client, renamer, job = make(env)
     job.fmt = fmt  # the snapshot taken when the file was queued
     await renamer.process(job)
     (_t, _f, kw), = client.sent
-    assert kw["thumb"] == b"\xff\xd8global" and job.state == "done"
+    assert kw["thumb"][:2] == b"\xff\xd8" and kw["thumb"] != b"\xff\xd8gone" and job.state == "done"  # its thumbnail went with it
     out = await probe(client.uploads[0])
     assert out.tags.get("title") == "One Piece"  # the snapshot's metadata is still applied
 

tests/test_resize.py

@@ -7,7 +7,7 @@ from PIL import Image
 from bot import app as appmod
 from bot import panels
 
-from .appkit import OWNER, STRANGER, click, data_of, jpeg, say, send_doc
+from .appkit import OWNER, STRANGER, auto_thumb, autofmt, click, data_of, jpeg, say, send_doc
 from .tgfakes import FakeEvent, FakeMessage, dispatch
 
 FULL_HD = (1920, 1080)
@@ -144,13 +144,13 @@ async def test_it_handles_one_image_per_command_and_extra_photos_do_not_replace_
     assert "/resize handles one file at a time" in extra.texts[0]
     assert (await send_photo(ctx, mid=52)).out == []
     assert len(results(ctx)) == 1
-    assert not await ctx.db.has_thumb(OWNER)  # none of the extra photos became the saved thumbnail
+    assert await autofmt(ctx) is None  # none of the extra photos became a thumbnail (that would have made the auto format)
     doc = await send_image_file(ctx, mid=53)
     assert doc.out == [] and ctx.app.queue.waiting == 0  # an image file right after is skipped as well, not auto-renamed
 
     ctx.app._recent[OWNER][1] -= appmod.ONE_SHOT_GRACE + 1
     await send_photo(ctx, mid=54)
-    assert await ctx.db.has_thumb(OWNER)  # after the grace a photo is a thumbnail again
+    assert await auto_thumb(ctx)  # after the grace a photo is the thumbnail of the auto format again
 
 
 async def test_large_results_are_sent_as_files_so_telegram_does_not_shrink_them(ctx):
@@ -196,7 +196,7 @@ async def test_it_expires_and_cancel_ends_it(ctx):
     ev = await say(ctx, OWNER, "/cancel")
     assert "Cancelled" in ev.texts[0] and OWNER not in ctx.app.modes
     await send_photo(ctx)
-    assert results(ctx) == [] and await ctx.db.has_thumb(OWNER)
+    assert results(ctx) == [] and await auto_thumb(ctx)
 
 
 async def test_a_format_thumbnail_prompt_takes_priority_over_a_waiting_resize(ctx):

tests/test_richtext.py

@@ -156,6 +156,8 @@ def test_of_two_overlapping_links_the_later_one_gets_what_is_left():
     ("[a=https://x.io]{ti[/a]tle}", '<a href="https://x.io">{title}</a>'),
     ("[b]Ep[/b] {episode} [i]x[/i]", "<b>Ep</b> {episode} <i>x</i>"),  # a format that does not touch a variable is left alone
     ("{[b]nonsense[/b]}", "{<b>nonsense</b>}"),  # only the variables the caption knows are held together
+    ("Ep {[b]2episode[/b]} here", "Ep <b>{2episode}</b> here"),  # the padded episode variables are held together too
+    ("[b]{3epis[/b]ode}", "<b>{3episode}</b>"),
 ])
 def test_a_format_never_cuts_a_variable_in_two(markup, expected):
     assert html_of(markup) == expected

tests/test_settings_ops.py

@@ -1,6 +1,8 @@
 import pytest
 
-from bot.db import DEFAULT_SETTINGS, Database
+from bot.db import DEFAULT_CAPTION, Database
+from bot.formats import AutoFormatSettings
+from bot.parser import DEFAULT_TEMPLATE
 from bot.settings_ops import META_COMMANDS, META_KINDS, apply_setting, parse_channel, preview_template
 
 UID = 7
@@ -18,38 +20,69 @@ async def get(db):
     return await db.get_settings(UID)
 
 
+async def auto(db):
+    """The auto format in use: the template and the caption are saved there, not in the user's settings."""
+    return await db.get_auto_format(UID)
+
+
+def store(db):
+    return AutoFormatSettings(db)
+
+
 async def test_template_saved_with_preview(db):
-    ok, msg = await apply_setting(db, UID, "template", "[S{season}E{episode}] {title} [{quality}]")
+    ok, msg = await apply_setting(store(db), UID, "template", "[S{season}E{episode}] {title} [{quality}]")
     assert ok and "Template saved" in msg and "Preview" in msg
-    assert (await get(db))["template"] == "[S{season}E{episode}] {title} [{quality}]"
+    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(db, UID, "template", "   "))[0] is False
-    ok, msg = await apply_setting(db, UID, "template", "x" * 201)
+    assert (await apply_setting(store(db), UID, "template", "   "))[0] is False
+    ok, msg = await apply_setting(store(db), UID, "template", "x" * 201)
     assert not ok and "too long" in msg
-    assert (await get(db))["template"] == DEFAULT_SETTINGS["template"]
-    await apply_setting(db, UID, "template", "{title}")
-    ok, _ = await apply_setting(db, UID, "template", "reset")
-    assert ok and (await get(db))["template"] == DEFAULT_SETTINGS["template"]
+    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"] == "{title}"
+    ok, _ = await apply_setting(store(db), 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(db, UID, "template", "{title} {nope}")
+    ok, msg = await apply_setting(store(db), UID, "template", "{title} {nope}")
     assert ok and "{nope}" in msg and "Unknown variables" in msg
-    assert (await get(db))["template"] == "{title} {nope}"
+    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}")
+    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}")
+    assert ok and "Unknown" not in msg
 
 
 async def test_caption_set_validate_reset(db):
-    ok, msg = await apply_setting(db, UID, "caption", "<b>{filename}</b> · {size}")
-    assert ok and (await get(db))["caption"] == "<b>{filename}</b> · {size}"
+    ok, msg = await apply_setting(store(db), 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(db, UID, "caption", "x" * 801))[0] is False
-    assert (await apply_setting(db, UID, "caption", ""))[0] is False
-    ok, msg = await apply_setting(db, UID, "caption", "{bogus}")
+    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 ok and "{bogus}" in msg
-    ok, _ = await apply_setting(db, UID, "caption", "reset")
-    assert ok and (await get(db))["caption"] == "<b>{filename}</b>"
+    ok, _ = await apply_setting(store(db), 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):

tests/test_share_app.py

@@ -310,7 +310,8 @@ async def test_adding_a_shared_format_gives_the_user_their_own_copy(ctx):
     assert mine["has_thumb"] and await ctx.db.get_format_thumb(ADMIN_CFG, mine["id"]) == jpeg()
     assert cb.toasts == ["Added to your formats."]
     text, buttons = cb.edits[-1]
-    assert "is now in your formats" in text and data_of(buttons) == [f"fm:v:{mine['id']}", "x:close"]
+    assert "is now in your manual formats" in text and "/rename" in text and data_of(buttons) == [f"fm:v:{mine['id']}", "x:close"]
+    assert mine["kind"] == "manual" and await ctx.db.count_formats(ADMIN_CFG, "auto") == 0
 
     # the copy is theirs: changing or deleting it leaves the owner's alone, and it shows up in their lists
     await ctx.db.update_format(ADMIN_CFG, mine["id"], template="Mine - {title}")
@@ -332,7 +333,7 @@ async def test_a_copy_is_renamed_when_the_name_is_taken_and_stops_at_the_limit(c
     for i in range(MAX_FORMATS - 2):
         await make_format(ctx, f"F{i}", uid=ADMIN_CFG)
     cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
-    assert cb.alerts == [f"You already have {MAX_FORMATS} formats. Delete one first."] and cb.edits == []
+    assert cb.alerts == [f"You already have {MAX_FORMATS} manual formats. Delete one first."] and cb.edits == []
     assert await ctx.db.count_formats(ADMIN_CFG) == MAX_FORMATS
 
 
@@ -362,3 +363,52 @@ async def test_the_shared_link_works_for_many_people_and_many_times(ctx):
     await click(ctx, ADMIN_CFG, f"fs:add:{token}")
     assert [f["name"] for f in await ctx.db.list_formats(ADMIN_CFG)] == ["One Piece", "One Piece (2)"]
     assert await ctx.db.count_formats(OWNER) == 1
+
+
+# ---------------------------------------------------------------------------
+# auto formats are shared and added as auto formats
+# ---------------------------------------------------------------------------
+
+
+async def test_a_shared_auto_format_is_added_as_an_auto_format(ctx):
+    fmt, token = await share(ctx, "Auto One", kind="auto", meta={"title": "One Piece"})
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{token}")
+    assert "🤖 Auto" in ev.texts[0] and "An auto rename format shared with you" in ev.texts[0] and "your auto formats" in ev.texts[0]
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    (mine,) = await ctx.db.list_formats(ADMIN_CFG)
+    assert mine["kind"] == "auto" and mine["name"] == "Auto One" and mine["meta"]["title"] == "One Piece"
+    text, buttons = cb.edits[-1]
+    assert "is now in your auto formats" in text and "/start menu" in text and data_of(buttons) == [f"fm:v:{mine['id']}", "x:close"]
+    assert (await ctx.db.get_auto_format(ADMIN_CFG))["id"] == mine["id"]  # their first auto format is the one in use
+    assert await ctx.db.count_formats(ADMIN_CFG, "manual") == 0 and (await ctx.db.get_format(OWNER, fmt["id"]))["kind"] == "auto"
+
+    title, description, card = panels.share_card(fmt)
+    assert "An auto rename format for this bot" in card and title == "🗂 Auto One" and description
+
+
+async def test_a_shared_format_keeps_its_kind_whoever_opens_it(ctx):
+    _fmt, token = await share(ctx, "Auto One", kind="auto")
+    ev = await say(ctx, OWNER, f"/start fmt_{token}")  # the owner looking at their own card
+    assert "your own format" in ev.texts[0] and "🤖 Auto" in ev.texts[0]
+    _plain, plain_token = await share(ctx, "Manual One")
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{plain_token}")
+    assert "A manual rename format shared with you" in ev.texts[0] and "✋ Manual" in ev.texts[0]
+
+
+async def test_the_limit_of_a_shared_format_is_the_one_of_its_kind(ctx):
+    _a, auto_token = await share(ctx, "Auto One", kind="auto")
+    _m, manual_token = await share(ctx, "Manual One")
+    for i in range(MAX_FORMATS):
+        await make_format(ctx, f"F{i}", uid=ADMIN_CFG)  # twelve manual formats
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{manual_token}")
+    assert cb.alerts == [f"You already have {MAX_FORMATS} manual formats. Delete one first."]
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{auto_token}")  # the auto formats are counted apart
+    assert cb.alerts == [] and await ctx.db.count_formats(ADMIN_CFG, "auto") == 1
+    assert await ctx.db.count_formats(ADMIN_CFG, "manual") == MAX_FORMATS
+
+
+async def test_the_share_card_of_an_auto_format_is_made_by_the_inline_query(ctx):
+    fmt = await make_format(ctx, "Auto One", kind="auto")
+    query = await ask(ctx, OWNER, f"share_{fmt['id']}")
+    (card,) = query.results
+    assert "An auto rename format" in card.send_message.message

tests/test_smedia.py

@@ -10,7 +10,7 @@ from telethon import types
 
 from bot import app as appmod
 
-from .appkit import ADMIN_CFG, OWNER, STRANGER, click, data_of, jpeg, say, send_doc
+from .appkit import ADMIN_CFG, OWNER, STRANGER, auto_thumb, autofmt, click, data_of, jpeg, say, send_doc
 from .tgfakes import FakeEvent, FakeMessage, dispatch, make_file
 
 GIF_BYTES = b"\x00\x00\x00\x18ftypmp42-fake-animation-bytes"
@@ -235,10 +235,10 @@ async def test_extra_files_right_after_are_skipped_and_do_not_become_the_thumbna
     assert "/smedia handles one file at a time" in extra.texts[0]
     assert (await send_photo(ctx, mid=52)).out == []  # the hint is given once
     assert (await send_gif(ctx)).out == [] and (await send_image_file(ctx, mid=53)).out == []
-    assert len(uploads(ctx)) == 1 and not await ctx.db.has_thumb(OWNER) and ctx.app.queue.waiting == 0
+    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 ctx.db.has_thumb(OWNER)  # after the grace a photo is a thumbnail again
+    assert await auto_thumb(ctx)  # after the grace a photo is the thumbnail of the auto format again
 
 
 # ---------------------------------------------------------------------------
@@ -280,7 +280,7 @@ async def test_when_nothing_can_be_sent_start_still_shows_the_menu(ctx):
     await send_photo(ctx)
     ctx.client.fail_send_file = True
     ev = await say(ctx, OWNER, "/start")
-    assert "Auto Rename Bot" in ev.texts[0] and data_of(ev.out[0][1])[0] == "m:rename"
+    assert "Auto Rename Bot" in ev.texts[0] and data_of(ev.out[0][1])[:2] == ["m:auto", "m:rename"]
 
 
 async def test_damaged_saved_media_never_breaks_start(ctx):

tests/test_stream_rename.py

@@ -142,6 +142,16 @@ def attributes_by_type(kwargs):
     return {type(a): a for a in kwargs["attributes"]}
 
 
+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)
+    if changes:
+        await env.db.update_format(42, fmt["id"], **changes)
+    if thumb:
+        await env.db.set_format_thumb(42, fmt["id"], thumb)
+    return await env.db.get_format(42, fmt["id"])
+
+
 # ---------------------------------------------------------------------------
 # the streamed way
 # ---------------------------------------------------------------------------
@@ -170,9 +180,8 @@ async def test_a_big_plain_rename_is_streamed_with_the_details_telegram_already_
     assert not (Path(env.cfg.temp_dir) / "job1").exists()
 
 
-async def test_the_users_thumbnail_wins_and_the_original_preview_is_then_not_even_fetched(env):
-    await env.db.set_thumb(42, b"\xff\xd8mine")
-    client, _job = await rename(env)
+async def test_the_formats_thumbnail_wins_and_the_original_preview_is_then_not_even_fetched(env):
+    client, _job = await rename(env, fmt=await auto(env, thumb=b"\xff\xd8mine"))
     assert client.sent[0][2]["thumb"] == b"\xff\xd8mine" and client.preview_downloads == 0 and len(client.relays) == 1
 
     fmt = await env.db.create_format(42, "One Piece")
@@ -182,7 +191,7 @@ async def test_the_users_thumbnail_wins_and_the_original_preview_is_then_not_eve
 
 
 async def test_a_format_streams_with_its_own_caption(env):
-    await env.db.update_settings(42, caption="<i>THE USER'S {filename}</i>")
+    await auto(env, caption="<i>THE AUTO FORMAT'S {filename}</i>")  # another format's caption is not borrowed
     fmt = await env.db.create_format(42, "One Piece", template="One Piece - E{episode}")
     await env.db.update_format(42, fmt["id"], caption="<b>{filename}</b> · {size} · {duration}")
     client, _job = await rename(env, new_name="One Piece - E5.mkv", fmt=await env.db.get_format(42, fmt["id"]))
@@ -201,8 +210,7 @@ async def test_a_file_that_gets_no_thumbnail_anyway_is_streamed_without_one(env)
 
 
 async def test_an_original_sent_as_a_file_is_streamed_as_a_file(env):
-    await env.db.set_thumb(42, b"\xff\xd8mine")
-    client, _job = await rename(env, FakeMessage())  # an .mkv without any video details: Telegram sent it as a file
+    client, _job = await rename(env, FakeMessage(), fmt=await auto(env, thumb=b"\xff\xd8mine"))  # an .mkv without any video details: Telegram sent it as a file
     (_t, _f, kw), = client.sent
     assert len(client.relays) == 1 and kw["force_document"] is True and kw["thumb"] == b"\xff\xd8mine"
     assert types.DocumentAttributeVideo not in attributes_by_type(kw)
@@ -225,8 +233,7 @@ async def test_a_forced_type_is_followed_when_telegram_has_the_details_for_it(en
 
 
 async def test_the_caption_may_use_the_duration_when_telegram_has_it(env):
-    await env.db.update_settings(42, caption="<b>{filename}</b> · {duration}")
-    client, _job = await rename(env)
+    client, _job = await rename(env, fmt=await auto(env, caption="<b>{filename}</b> · {duration}"))
     assert client.sent[0][2]["caption"] == f"<b>[S01E05] Tokyo Revengers [1080p]</b> · {human_duration(1400.5)}" and len(client.relays) == 1
 
 
@@ -315,9 +322,8 @@ async def test_a_forced_video_or_audio_type_needs_the_details_only_the_file_can_
 
 @needs_ffmpeg
 async def test_a_caption_that_wants_the_duration_needs_the_file_when_telegram_does_not_know_it(env):
-    await env.db.update_settings(42, caption="<b>{filename}</b> · {duration}")
-    await env.db.set_thumb(42, b"\xff\xd8mine")
-    client, job = await rename(env, FakeMessage())  # sent as a file: no duration
+    fmt = await auto(env, thumb=b"\xff\xd8mine", caption="<b>{filename}</b> · {duration}")
+    client, job = await rename(env, FakeMessage(), fmt=fmt)  # sent as a file: no duration
     usual_way(client, job)
     duration = (await probe(env.media_dir / "sample.mkv")).duration
     assert client.sent[0][2]["caption"] == f"<b>[S01E05] Tokyo Revengers [1080p]</b> · {human_duration(duration)}"  # read from the file
@@ -421,6 +427,15 @@ def test_make_caption_fills_in_what_it_is_given():
     assert len(make_caption("x" * 5000, new_name="a.mkv", orig_name="a.mkv", ext=".mkv", size=1, duration=0)) == 1000
 
 
+def test_make_caption_pads_the_episode_when_asked_to():
+    text = make_caption("Ep {episode} / {1episode} / {2episode} / {3episode}", new_name="x.mkv",
+                        orig_name="Show - 7 [720p].mkv", ext=".mkv", size=1, duration=0)
+    assert text == "Ep 07 / 07 / 007 / 0007"
+    assert make_caption("{3episode} {3episode}", new_name="x.mkv", orig_name="Show - 321 [720p].mkv", ext=".mkv", size=1, duration=0) == "0321 0321"
+    assert make_caption("{3episode}", new_name="x.mkv", orig_name="Show - 1321 [720p].mkv", ext=".mkv", size=1, duration=0) == "1321"
+    assert make_caption("<b>{2episode}</b>", new_name="x.mkv", orig_name="Plain.mkv", ext=".mkv", size=1, duration=0) == "<b></b>"
+
+
 async def test_the_embedded_preview_is_only_fetched_when_it_is_worth_having():
     class Client:
         def __init__(self, data=PREVIEW, error=None):