Automated sync from GitHub

.gitattributes

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

@@ -41,7 +41,7 @@ from .parser import compute_new_name, missing_variables, parse_caption, parse_in
 from .pipeline import PROBE_EXTS, Renamer, embedded_thumb, original_name_of, source_ext
 from .queue import Job, JobQueue
 from .sequence import SeqItem, SequenceState, analyse, format_report
-from .settings_ops import CLEAR_WORDS, META_COMMANDS, apply_setting, parse_channel, preview_template
+from .settings_ops import CLEAR_WORDS, META_COMMANDS, apply_setting, parse_channel
 from .telegraph import Telegraph, TelegraphError
 from .utils import clip, esc, human_size, human_uptime
 
@@ -55,8 +55,6 @@ COMMANDS = [
     ("sequence", "Collect files to sort by episode"),
     ("sort", "Sort the collected files by episode"),
     ("mode", "Choose Filename or Caption mode"),
-    ("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"),
@@ -66,8 +64,6 @@ 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 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)"),
@@ -347,13 +343,11 @@ 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, "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,
+            "sequence": self.cmd_sequence, "sort": self.cmd_sort, "mode": self.cmd_mode, "filetype": self.cmd_filetype,
             "metadata": self.cmd_metadata, "keepaudio": self._cmd_keep("keep_audio", "Keep Audio", "/keepaudio English Japanese"),
             "keepsubtitle": self._cmd_keep("keep_subtitle", "Keep Subtitle", "/keepsubtitle English"),
             "tracks": self.cmd_tracks, "check": self.cmd_check, "mediainfo": self.cmd_mediainfo,
             "ethumb": self.cmd_ethumb, "resize": self.cmd_resize,
-            "thumb": self.cmd_thumb, "delthumb": self.cmd_delthumb,
             "removewords": self.cmd_remove, "setchannel": self.cmd_setchannel, "queue": self.cmd_queue,
             "cancel": self.cmd_cancel, "speed": self.cmd_speed, "status": self.cmd_status, "stats": self.cmd_stats,
             "addadmin": self.cmd_addadmin, "deladmin": self.cmd_deladmin, "admins": self.cmd_admins, "smedia": self.cmd_smedia,
@@ -367,15 +361,14 @@ class App:
         return (event.pattern_match.group(1) or "").strip() if event.pattern_match else ""
 
     @staticmethod
-    def _caption_input(event: Any, start: int = 0) -> str:
-        """The caption the person sent (the message from ``start`` on).  Formatting they put on it in Telegram (bold, italic,
-        links...) becomes the HTML that is stored, so nobody has to type tags; without any formatting it is taken as typed."""
-        raw = event.raw_text or ""
-        typed = raw[start:]
+    def _caption_input(event: Any) -> str:
+        """The caption the person sent.  Formatting they put on it in Telegram (bold, italic, links...) becomes the HTML that is
+        stored, so nobody has to type tags; without any formatting it is taken as typed."""
+        typed = event.raw_text or ""
         if typed.strip().lower() in CLEAR_WORDS:  # "reset" stays a reset even if it was made bold
             return typed
         entities = getattr(getattr(event, "message", None), "entities", None)
-        return richtext.from_entities(raw, entities, start) or typed
+        return richtext.from_entities(typed, entities) or typed
 
     async def _reply(self, event: Any, text: str, rows: Optional[List[panels.Row]] = None) -> Any:
         buttons = panels.to_buttons(rows) if rows else None
@@ -551,47 +544,6 @@ class App:
         """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._store("template"), uid, "template", arg)
-            await self._reply(event, msg)
-            return
-        auto = await self.db.get_auto_format(uid) or default_auto_format()
-        await self._reply(
-            event,
-            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:
-            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
-        auto = await self.db.get_auto_format(uid) or default_auto_format()
-        await self._reply(
-            event,
-            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"
-            "Restore the default: <code>/caption reset</code>",
-        )
-
     async def cmd_remove(self, event: Any) -> None:
         arg = self._args(event)
         uid = event.sender_id
@@ -660,10 +612,10 @@ class App:
         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.
+        """The auto format a thumbnail button is about.
 
         A button names its format (``th:rm:12``), so an old message never reaches the thumbnail of whichever format is in use
-        now; a command, and the buttons of messages from before that, mean the one in use.  ``None``: there is no such format.
+        now; the buttons of messages from before that carry no id and mean the one in use.  ``None``: there is no such format.
         """
         if fid is None:
             return await self.db.get_auto_format(uid)
@@ -682,13 +634,6 @@ class App:
             return False
         return await self.db.set_format_thumb(uid, auto["id"], None)
 
-    async def cmd_thumb(self, event: Any) -> None:
-        auto, data = await self._auto_thumb(event.sender_id)
-        if not data:
-            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, auto["id"])
-
     async def _send_thumb(self, chat_id: int, data: bytes, fid: int) -> None:
         bio = io.BytesIO(data)
         bio.name = "thumbnail.jpg"
@@ -697,12 +642,6 @@ class App:
             buttons=panels.to_buttons([[("🗑 Delete", f"th:rm:{fid}"), ("✖ Close", "x:close")]]),
         )
 
-    async def cmd_delthumb(self, event: Any) -> None:
-        if await self._delete_auto_thumb(event.sender_id):
-            await self._reply(event, "🗑 Thumbnail deleted.")
-        else:
-            await self._reply(event, "Your auto format has no thumbnail.")
-
     async def on_photo(self, event: Any) -> None:
         uid = event.sender_id
         p = self.pending.get(uid)

bot/db.py

@@ -530,7 +530,7 @@ class Database:
     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
+        That is what lets the Template and Caption buttons and a thumbnail photo work for someone who never made a format.  Several photos
         sent at once ask for it at the same moment, so one user is served at a time: the first makes it, the others find it.
         """
         async with self._default_locks.setdefault(uid, asyncio.Lock()):

bot/formats.py

@@ -121,7 +121,7 @@ class FormatSettings:
 
 
 class AutoFormatSettings:
-    """The auto format in use, edited the way a setting is: ``/template``, ``/caption`` and their buttons go through here.
+    """The auto format in use, edited the way a setting is: the Template and Caption buttons go through here.
 
     A user who has no auto format gets one called "Default" the first time they change something.
     """

bot/panels.py

@@ -236,7 +236,7 @@ def help_panel() -> Panel:
         "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"
+        "4. /start → Rename, Caption &amp; Thumbnail — edit your auto format.\n"
         "5. /mode — read details from the file name or the caption.\n"
         "6. /metadata, /keepaudio, /keepsubtitle — default metadata and tracks (formats can copy it).\n"
         "7. /filetype — send as document, video or audio.\n"

bot/richtext.py

@@ -119,7 +119,7 @@ def _render(body: str, spans: Iterable[Span]) -> str:
 def from_entities(text: str, entities: Optional[Iterable[Any]], start: int = 0) -> Optional[str]:
     """``text[start:]`` as HTML that carries the formatting in ``entities``, or ``None`` when there is none to keep.
 
-    ``start`` skips what comes before the caption (a ``/caption`` command).  A ``{variable}`` is never split: a format that
+    ``start`` skips what comes before the caption (a command word, say).  A ``{variable}`` is never split: a format that
     covers only part of one (double-tapping the word inside the braces does that) is widened to the whole variable, because
     the variable is replaced as a whole.
     """

tests/appkit.py

@@ -86,6 +86,12 @@ async def set_auto_thumb(ctx, data, uid=OWNER):
     return fmt
 
 
+async def edit_auto(ctx, uid=OWNER, **changes):
+    """Change the user's auto format (``template=...``, ``caption=...``), making the "Default" one first if they have none."""
+    fmt = await ctx.db.ensure_auto_format(uid)
+    return await ctx.db.update_format(uid, fmt["id"], **changes)
+
+
 def jpeg(size=(640, 480)):
     buf = io.BytesIO()
     Image.new("RGB", size, (200, 30, 30)).save(buf, "JPEG")

tests/test_app.py

@@ -16,8 +16,8 @@ from bot.queue import JobQueue
 
 from .conftest import needs_ffmpeg
 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,
+    ADMIN_CFG, ADMIN_DB, EPISODE, EPISODE_NEW, LOG, OWNER, STRANGER, auto_thumb, autofmt, click, data_of, edit_auto, 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,
@@ -166,25 +166,36 @@ async def test_metadata_command(ctx):
     assert "currently: Off" in ev.texts[0]
 
 
-async def test_template_caption_and_removewords_commands(ctx):
+async def test_the_template_and_caption_buttons_edit_the_auto_format_and_make_it_when_needed(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
+    await click(ctx, OWNER, "in:template", msg_id=500)
+    assert await autofmt(ctx) is None  # only opening the prompt: no format is made
 
-    ev = await say(ctx, OWNER, "/template [S{season}E{episode}] {title} [{quality}]")
-    assert "Template saved" in ev.texts[0]
-    auto = await autofmt(ctx)  # they are the template and caption of the auto format in use, made on the first change
+    await say(ctx, OWNER, "[S{season}E{episode}] {title} [{quality}]", mid=60)
+    assert "Template saved" in ctx.client.edited[-1][1]
+    auto = await autofmt(ctx)  # it is the template of the auto format in use, made on the first change
     assert auto["name"] == "Default" and auto["kind"] == "auto"
     assert auto["template"] == "[S{season}E{episode}] {title} [{quality}]"
     assert "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
+    assert "[S{season}E{episode}] {title} [{quality}]" in (await click(ctx, OWNER, "m:rename")).edits[-1][0]
 
-    await say(ctx, OWNER, "/caption <b>{filename}</b> {size}")
+    await click(ctx, OWNER, "in:caption", msg_id=501)
+    await say(ctx, OWNER, "<b>{filename}</b> {size}", mid=61)
     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
 
+
+@pytest.mark.parametrize("command", ["template", "caption", "thumb", "delthumb"])
+async def test_the_template_caption_and_thumbnail_commands_are_gone(ctx, command):
+    assert command not in [name for name, _description in COMMANDS] and command not in ctx.app._command_table()
+    await set_auto_thumb(ctx, b"\xff\xd8thumb")
+    before = await autofmt(ctx)
+    ev = await say(ctx, OWNER, f"/{command} something {{title}}")
+    assert ev.out == []  # not a command any more: nothing answers it
+    assert await autofmt(ctx) == before and await auto_thumb(ctx) == b"\xff\xd8thumb"
+
+
+async def test_removewords_command(ctx):
     await say(ctx, OWNER, "/removewords @Chan, [Group]")
     assert (await prefs(ctx))["remove_words"] == ["@Chan", "[Group]"]
     assert "@Chan, [Group]" in (await say(ctx, OWNER, "/removewords")).texts[0]
@@ -192,10 +203,10 @@ async def test_template_caption_and_removewords_commands(ctx):
     assert (await prefs(ctx))["remove_words"] == []
 
 
-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])
+async def test_template_and_caption_prompts_list_each_variable_as_its_own_copyable_block(ctx):
+    line, blocks = variables_line((await click(ctx, OWNER, "in:template")).edits[-1][0])
     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])
+    line, blocks = variables_line((await click(ctx, OWNER, "in:caption")).edits[-1][0])
     assert blocks == line.split(": ", 1)[1].split() and "{size}" in blocks and "{3episode}" in blocks and "{4episode}" not in blocks and len(blocks) == 13
 
 
@@ -260,25 +271,27 @@ async def test_setchannel(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
+    cb = await click(ctx, OWNER, "th:view")
+    assert cb.alerts and "no thumbnail" in cb.alerts[0] and await autofmt(ctx) is None
     ev = FakeEvent(OWNER, message=FakeMessage("", mid=20, photo=True), photo_bytes=jpeg())
     await dispatch(ctx.client, ev)
     assert "Thumbnail saved" in ev.texts[0] and "auto format" in ev.texts[0]
-    auto = await autofmt(ctx)  # the first photo makes the auto format "Default" (like /template does)
+    auto = await autofmt(ctx)  # the first photo makes the auto format "Default" (like the first template change does)
     assert auto["name"] == "Default" and auto["has_thumb"]
     assert f"th:rm:{auto['id']}" in data_of(ev.out[0][1])  # the button names the format whose thumbnail it deletes
     stored = await auto_thumb(ctx)
     assert stored[:2] == b"\xff\xd8"
     assert await auto_thumb(ctx, ADMIN_CFG) is None and await autofmt(ctx, ADMIN_CFG) is None  # per user
 
-    await say(ctx, OWNER, "/thumb")
+    await click(ctx, OWNER, "th:view")
     (chat, file, kw), = ctx.client.files
     assert chat == OWNER and file.read() == stored and f"th:rm:{auto['id']}" in data_of(kw["buttons"])
 
-    assert "deleted" in (await say(ctx, OWNER, "/delthumb")).texts[0]
+    cb = await click(ctx, OWNER, f"th:del:{auto['id']}")  # Delete Thumb in the Caption & Thumbnail panel
     assert await auto_thumb(ctx) is None and (await autofmt(ctx))["id"] == auto["id"]  # the format stays
-    assert "no thumbnail" in (await say(ctx, OWNER, "/delthumb")).texts[0]
-    assert "no thumbnail" in (await say(ctx, OWNER, "/thumb")).texts[0]
+    assert "none" in cb.edits[-1][0] and cb.toasts == ["Thumbnail deleted."]
+    cb = await click(ctx, OWNER, "th:view")
+    assert cb.alerts and "no thumbnail" in cb.alerts[0]
 
 
 async def test_a_photo_goes_to_the_auto_format_in_use_and_never_to_a_manual_one(ctx):
@@ -336,7 +349,7 @@ async def test_thumbnail_buttons_name_their_format_so_an_old_message_never_hits_
     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"
+    await click(ctx, OWNER, "th:view")  # the Delete button under the thumbnail it sends belongs to "One"
     (_chat, _file, kw), = ctx.client.files
     assert data_of(kw["buttons"])[0] == f"th:rm:{one['id']}"
     _text, rows = await ctx.app.panel(OWNER, "cap")  # the panel names the format it shows, too
@@ -413,7 +426,7 @@ async def test_remove_words_are_applied_to_the_new_name(ctx):
 
 
 async def test_the_one_piece_style_name_gets_its_episode_number(ctx):
-    await say(ctx, OWNER, "/template One Piece - E{episode}")
+    await edit_auto(ctx, template="One Piece - E{episode}")
     ev = await send_doc(ctx, OWNER, "1147 - One Piece [Dual] 720p @Anime_X_Universe.mkv", mid=21)
     (job,) = ctx.app.queue.jobs.values()
     assert job.new_name == "One Piece - E1147.mkv" and job.notes == []
@@ -421,7 +434,7 @@ async def test_the_one_piece_style_name_gets_its_episode_number(ctx):
 
 
 async def test_a_template_variable_that_cannot_be_filled_is_flagged(ctx):
-    await say(ctx, OWNER, "/template One Piece - E{episode}")
+    await edit_auto(ctx, template="One Piece - E{episode}")
     ev = await send_doc(ctx, OWNER, "Plain Movie.mkv")
     (job,) = ctx.app.queue.jobs.values()
     assert job.new_name == "One Piece - E.mkv"
@@ -734,7 +747,7 @@ async def test_toggles_update_settings_and_refresh_the_panel(ctx):
 
 
 async def test_clear_buttons(ctx):
-    await say(ctx, OWNER, "/caption custom {filename}")
+    await edit_auto(ctx, caption="custom {filename}")
     assert (await autofmt(ctx))["caption"] == "custom {filename}"
     cb = await click(ctx, OWNER, "clr:caption")
     assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>" and "CAPTION" in cb.edits[-1][0]

tests/test_caption_formatting_app.py

@@ -1,108 +1,107 @@
 """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."""
+The Set Caption button edits 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, autofmt, click, data_of, say, say_formatted
+from .appkit import OWNER, autofmt, click, data_of, edit_auto, say, say_formatted
 from .test_formats_app import make_format
 
 FORMATTED = "[b]Watch[/b] {title} [i]episode {episode}[/i] on [a=https://t.me/Anime_X]our channel[/a]"
 STORED = '<b>Watch</b> {title} <i>episode {episode}</i> on <a href="https://t.me/Anime_X">our channel</a>'
 
 
+async def set_caption(ctx, markup, *, formatted=True):
+    """Tap Set Caption and send the caption (``markup`` as ``say_formatted`` takes it, or typed as it is with ``formatted=False``).
+
+    Returns the message sent and the text the prompt's message turned into once the caption was taken (empty when it was refused)."""
+    edited = len(ctx.client.edited)
+    await click(ctx, OWNER, "in:caption", msg_id=500)
+    ev = await (say_formatted if formatted else say)(ctx, OWNER, markup)
+    return ev, (ctx.client.edited[-1][1] if len(ctx.client.edited) > edited else "")
+
+
 # ---------------------------------------------------------------------------
-# /caption
+# the Set Caption button, then the caption
 # ---------------------------------------------------------------------------
 
 
-async def test_the_caption_command_keeps_the_formatting_that_was_applied(ctx):
-    ev = await say_formatted(ctx, OWNER, "/caption " + FORMATTED)
+async def test_the_set_caption_prompt_keeps_the_formatting(ctx):
+    cb = await click(ctx, OWNER, "in:caption", msg_id=500)
+    assert "No HTML needed" in cb.edits[-1][0]
+    ev = await say_formatted(ctx, OWNER, FORMATTED, mid=60)
+    assert ev.deleted and OWNER not in ctx.app.pending
     assert (await autofmt(ctx))["caption"] == STORED
-    assert "Caption template saved" in ev.texts[0] and "Unknown" not in ev.texts[0]
+    (chat, text, kw), = ctx.client.edited
+    assert kw["message"] == 500 and "Caption template saved" in text and "CAPTION" in text and "Unknown" not in text
+    assert STORED in text and "&lt;b&gt;" not in text  # the panel shows the caption formatted
+    assert "in:caption" in data_of(kw["buttons"])
 
 
-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 "Caption of your auto format" in text and STORED in text  # shown as the person wrote it, not as tags to read
+async def test_the_caption_screen_shows_the_caption_with_its_formatting(ctx):
+    await edit_auto(ctx, caption=STORED)
+    text = (await click(ctx, OWNER, "m:cap")).edits[-1][0]
+    assert "Of the auto format" in text and STORED in text  # shown as the person wrote it, not as tags to read
     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}")
+async def test_a_caption_may_have_several_lines(ctx):
+    await set_caption(ctx, "[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]")
+    await set_caption(ctx, "🔥🔥 [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>")
+    await set_caption(ctx, "<i>{filename}</i> · <a href=\"https://t.me/x\">join</a>", formatted=False)
     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]")
+    await set_caption(ctx, "<i>{filename}</i> [tag]#anime[/tag] [at]@channel[/at]")
     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]")
+    await set_caption(ctx, "<b>{filename}</b> [i]x[/i]")
     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}")
+    await set_caption(ctx, "[spoiler]secret[/spoiler] {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 autofmt(ctx))["caption"] == "<b>{filename}</b>" and "Caption template saved" in ev.texts[0]
+    await edit_auto(ctx, caption="custom {filename}")
+    _ev, text = await set_caption(ctx, "[b]reset[/b]")
+    assert (await autofmt(ctx))["caption"] == "<b>{filename}</b>" and "Caption template saved" in text
 
 
 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]")
+    _ev, text = await set_caption(ctx, "{[b]filename[/b]} · {siz[i]e} left[/i]")
     assert (await autofmt(ctx))["caption"] == "<b>{filename}</b> · <i>{size} left</i>"
-    assert "Unknown" not in ev.texts[0]
+    assert "Unknown" not in text
 
 
 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]
+    _ev, text = await set_caption(ctx, "[b]{filename}[/b] {nonsense}")
+    assert "Unknown variables" in text and "{nonsense}" in text
     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]
+    ev, text = await set_caption(ctx, f"[a=https://example.com/{'a' * 800}]link[/a] {{filename}}")
+    assert "too long" in ev.texts[0] and "link addresses" in ev.texts[0] and text == ""
     assert await autofmt(ctx) is None  # nothing was saved, so there is no format either
 
 
-# ---------------------------------------------------------------------------
-# the Set Caption button, then the caption
-# ---------------------------------------------------------------------------
-
-
-async def test_the_set_caption_prompt_keeps_the_formatting(ctx):
-    cb = await click(ctx, OWNER, "in:caption", msg_id=500)
-    assert "No HTML needed" in cb.edits[-1][0]
-    ev = await say_formatted(ctx, OWNER, FORMATTED, mid=60)
-    assert ev.deleted and OWNER not in ctx.app.pending
-    assert (await autofmt(ctx))["caption"] == STORED
-    (chat, text, kw), = ctx.client.edited
-    assert kw["message"] == 500 and "Caption template saved" in text and "CAPTION" in text
-    assert STORED in text and "&lt;b&gt;" not in text  # the panel shows the caption formatted
-    assert "in:caption" in data_of(kw["buttons"])
-
-
 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}")
@@ -133,7 +132,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 say(ctx, OWNER, "/caption <u>{filename}</u>")  # the auto format in use has a caption of its own
+    await edit_auto(ctx, 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)
@@ -174,7 +173,7 @@ async def test_a_format_caption_reset_works_in_bold_and_other_fields_stay_plain(
 
 
 async def test_a_link_in_a_caption_gets_no_link_preview_on_any_screen_that_shows_it(ctx):
-    await say_formatted(ctx, OWNER, "/caption " + FORMATTED)
+    await edit_auto(ctx, caption=STORED)
     cb = await click(ctx, OWNER, "m:cap")
     assert STORED in cb.edits[-1][0] and cb.edit_kwargs[-1]["link_preview"] is False
 
@@ -198,7 +197,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]")
+    await set_caption(ctx, "[b]{filename}[/b] · [i]{size}[/i] · [a=https://t.me/x]{original}[/a]")
     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"
@@ -212,7 +211,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]")
+    await set_caption(ctx, "[b]{filename}[/b] [i]{original}[/i]")
     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"

tests/test_check.py

@@ -1,5 +1,5 @@
 """/check: what the bot can read from a file's name and caption."""
-from .appkit import OWNER, say
+from .appkit import OWNER, edit_auto, say
 from .tgfakes import FakeMessage, document_message
 
 NAME = "[S01 E02] Dragon Ball Super Beerus [1080p].mkv"
@@ -44,7 +44,7 @@ async def test_year_and_codec_show_up_when_the_file_has_them(ctx):
 
 
 async def test_the_current_mode_is_shown_and_decides_the_new_name(ctx):
-    await say(ctx, OWNER, "/template [S{season}E{episode}] {title} [{quality}]")
+    await edit_auto(ctx, template="[S{season}E{episode}] {title} [{quality}]")
     reply = document_message("random.mkv", caption="One Piece - S01E1147 [720p]")
     ev = await say(ctx, OWNER, "/check", reply=reply)
     assert "<code>FILENAME</code>" in ev.texts[0]
@@ -58,7 +58,7 @@ async def test_the_current_mode_is_shown_and_decides_the_new_name(ctx):
 
 
 async def test_the_new_name_follows_the_users_template_and_remove_words(ctx):
-    await say(ctx, OWNER, "/template {title} - E{episode}")
+    await edit_auto(ctx, template="{title} - E{episode}")
     await say(ctx, OWNER, "/removewords @Anime_X_Universe")
     reply = document_message("1147 - One Piece [Dual] 720p @Anime_X_Universe.mkv")
     ev = await say(ctx, OWNER, "/check", reply=reply)

tests/test_formats.py

@@ -270,7 +270,7 @@ async def test_settings_ops_edit_a_formats_caption_with_the_checks_of_the_auto_f
     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, as for /caption
+    assert ok and "Unknown variables" in msg and "{nonsense}" in msg  # kept as plain text, as for the auto format's 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", "")

tests/test_formats_app.py

@@ -237,7 +237,7 @@ async def test_a_formats_caption_is_its_own_and_can_be_reset(ctx):
     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 /caption: too long keeps the prompt open
+    ev = await say(ctx, OWNER, "x" * 801)  # the same checks as the Set Caption prompt: 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}")

tests/test_richtext.py

@@ -86,11 +86,11 @@ def test_emoji_do_not_move_the_formatting():
     assert html_of("🔥🔥 [b]Hello[/b] 👨‍👩‍👧 [i]x[/i]") == "🔥🔥 <b>Hello</b> 👨‍👩‍👧 <i>x</i>"
 
 
-def test_the_command_in_front_is_skipped():
-    text, entities = telegram_text("/caption [b]Hi[/b] there")
-    assert from_entities(text, entities, start=len("/caption ")) == "<b>Hi</b> there"
-    whole = types.MessageEntityBold(0, len("/caption Hi"))  # formatting that began inside the command is cut at the caption
-    assert from_entities("/caption Hi", [whole], start=9) == "<b>Hi</b>"
+def test_a_prefix_in_front_is_skipped():
+    text, entities = telegram_text("/words [b]Hi[/b] there")
+    assert from_entities(text, entities, start=len("/words ")) == "<b>Hi</b> there"
+    whole = types.MessageEntityBold(0, len("/words Hi"))  # formatting that began inside the prefix is cut where the caption starts
+    assert from_entities("/words Hi", [whole], start=len("/words ")) == "<b>Hi</b>"
 
 
 def test_start_counts_characters_not_utf16_units():

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, auto_thumb, autofmt, click, data_of, jpeg, say, send_doc
+from .appkit import ADMIN_CFG, OWNER, STRANGER, auto_thumb, autofmt, click, data_of, edit_auto, jpeg, say, send_doc
 from .tgfakes import FakeEvent, FakeMessage, dispatch, make_file
 
 GIF_BYTES = b"\x00\x00\x00\x18ftypmp42-fake-animation-bytes"
@@ -297,7 +297,7 @@ async def test_damaged_saved_media_never_breaks_start(ctx):
 async def test_the_menu_fits_in_a_caption(ctx):
     await choose(ctx, "image")
     await send_photo(ctx)
-    await say(ctx, OWNER, "/template " + "{title} " * 30)
+    await edit_auto(ctx, template="{title} " * 30)
     await say(ctx, OWNER, "/start")
     assert appmod.visible_len(ctx.client.files[-1][2]["caption"]) < 1024
 

tests/tgfakes.py

@@ -30,7 +30,7 @@ _ENTITY_TAGS = {
 def telegram_text(markup: str) -> Tuple[str, List[Any]]:
     """A message the way Telegram delivers it: the plain text and the formatting as entities.
 
-    ``"/caption [b]Hi[/b] [a=https://x.io]a link[/a]"`` -> ``("/caption Hi a link", [command, bold, link])``.  Tags: b i u s code
+    ``"/mode [b]Hi[/b] [a=https://x.io]a link[/a]"`` -> ``("/mode Hi a link", [command, bold, link])``.  Tags: b i u s code
     quote spoiler tag at, ``[pre=python]``, ``[a=url]``; tags may overlap.  Offsets count UTF-16 units, like Telegram's.
     """
     text, entities, open_tags, position = "", [], [], 0