Automated sync from GitHub

.gitattributes

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

bot/app.py

@@ -25,7 +25,7 @@ from . import errorlog, media, mediainfo, panels, speed, sysinfo
 from .config import Config
 from .db import MAX_FORMATS, Database
 from .errors import FormatError
-from .formats import FIELD_KINDS, FormatSettings, validate_name
+from .formats import FIELD_KINDS, NAME_MAX, FormatSettings, validate_name
 from .parser import compute_new_name, missing_variables, parse_caption, parse_info, split_ext
 from .pipeline import PROBE_EXTS, Renamer, original_name_of, source_ext
 from .queue import Job, JobQueue
@@ -82,13 +82,20 @@ START_MEDIA_MAX_BYTES = 10 * 1024 * 1024  # biggest /start picture or GIF; a cop
 START_IMAGE_BOX = 1280  # pictures are shrunk to fit this box, as Telegram does with photos
 RESIZE_MAX_BYTES = 20 * 1024 * 1024
 SEQUENCE_WAIT = 1800  # seconds /sequence keeps the collected files without a new one arriving
-SEQUENCE_MAX = 200  # files one /sequence collects
+SEQUENCE_MAX = 1000  # files one /sequence collects
 SEQUENCE_STATUS_DELAY = 1.2  # seconds without a new file before "N files collected" is sent
 SORT_GAP = 0.3  # seconds between the files /sort sends back
+SORT_FAST_FILES = 200  # /sort sends this many files at that pace; the rest of a long batch goes at SORT_SLOW_GAP
+SORT_SLOW_GAP = 0.8  # about one file a second, what Telegram lets a bot keep sending into one chat without flood waits
+SORT_LOOKUP = 100  # files /sort looks up per request (Telegram returns at most 100 messages at a time)
 SORT_MAX_WAIT = 120  # a Telegram flood wait longer than this (seconds) stops /sort instead of being waited out
 SORT_PROGRESS_EVERY = 10  # files between two updates of the "Sorting…" message
 TRACKS_PROBE_BYTES = 12 * 1024 * 1024
 TRACKS_FULL_LIMIT = 700 * 1024 * 1024
+SHARE_PREFIX = "fmt_"  # /start fmt_<token> opens a shared format: it is the link on the card the Share format button makes
+SHARE_QUERY = re.compile(r"share_(\d{1,9})")  # what that button types into the chosen chat: share_<format id>
+SHARE_TOKEN = re.compile(r"[A-Za-z0-9_-]{1,32}")
+INLINE_RECHECK = 60  # seconds before the bot looks again whether inline mode is on, while it was off
 
 
 @dataclass
@@ -198,6 +205,9 @@ class App:
         self.renamer = Renamer(client, cfg, db)
         self.queue = JobQueue(self.renamer.process, workers=cfg.max_jobs, on_cancelled=self._on_job_cancelled, settle=QUEUE_SETTLE)
         self._warned: Set[int] = set()
+        self._username: Optional[str] = None  # the bot's own @username, for the links on shared-format cards
+        self._inline_on = False  # is inline mode on for the bot?  See _check_inline
+        self._inline_checked: Optional[float] = None
 
     # ------------------------------------------------------------------ auth
     def is_owner(self, uid: Optional[int]) -> bool:
@@ -212,6 +222,7 @@ class App:
         self.client.parse_mode = "html"
         self._register()
         await self._set_commands()
+        await self._check_inline(force=True)
         if self.cfg.log_channel:
             try:
                 await self.client.get_input_entity(self.cfg.log_channel)
@@ -278,6 +289,17 @@ class App:
 
         return wrapper
 
+    def _guard_inline(self, fn: Callable[[Any], Awaitable[None]]):
+        guarded = self._guard(fn)
+
+        async def wrapper(event: Any) -> None:
+            if self.is_allowed(event.sender_id):
+                await guarded(event)
+            else:  # anyone can type the bot's name in a chat: strangers get no results, and no notice in the log
+                await self._answer_inline(event, [])
+
+        return wrapper
+
     async def _stranger(self, uid: Optional[int]) -> None:
         if uid is None or uid in self._warned:
             return
@@ -300,6 +322,7 @@ class App:
         add(self._guard(self.on_gif), events.NewMessage(incoming=True, func=lambda e: e.is_private and e.message.gif is not None))
         add(self._guard(self.on_text), events.NewMessage(incoming=True, func=self._wants_text))
         add(self._guard(self.on_callback), events.CallbackQuery())
+        add(self._guard_inline(self.on_inline), events.InlineQuery())
         add(self._on_stranger, events.NewMessage(incoming=True, func=lambda e: e.is_private and not self.is_allowed(e.sender_id)))
 
     async def _on_stranger(self, event: Any) -> None:
@@ -333,7 +356,14 @@ class App:
 
     async def _reply(self, event: Any, text: str, rows: Optional[List[panels.Row]] = None) -> Any:
         buttons = panels.to_buttons(rows) if rows else None
-        return await event.respond(text, buttons=buttons, parse_mode="html", link_preview=False)
+        try:
+            return await event.respond(text, buttons=buttons, parse_mode="html", link_preview=False)
+        except errors.BotInlineDisabledError:  # inline mode was switched off in @BotFather: the Share button can't be shown
+            plain_rows = panels.without_inline(rows or [])
+            if plain_rows == rows:
+                raise
+            self._inline_refused()
+            return await self._reply(event, text, plain_rows)
 
     # ----------------------------------------------------------------- panels
     async def panel(self, uid: int, name: str) -> panels.Panel:
@@ -375,6 +405,12 @@ class App:
             await event.edit(text, buttons=panels.to_buttons(rows), parse_mode="html")
         except errors.MessageNotModifiedError:
             pass
+        except errors.BotInlineDisabledError:  # inline mode was switched off in @BotFather: the Share button can't be shown
+            plain_rows = panels.without_inline(rows)
+            if plain_rows == rows:
+                raise
+            self._inline_refused()
+            await self._edit_panel(event, text, plain_rows)
 
     # ------------------------------------------------------------------ modes
     def _mode(self, uid: int, *kinds: str) -> Optional[Mode]:
@@ -437,6 +473,10 @@ class App:
     # --------------------------------------------------------------- commands
     async def cmd_start(self, event: Any) -> None:
         self.pending.pop(event.sender_id, None)
+        arg = self._args(event)
+        if arg.startswith(SHARE_PREFIX):  # somebody opened the link on a shared format
+            await self._open_shared(event, arg[len(SHARE_PREFIX):])
+            return
         text, rows = await self.panel(event.sender_id, "home")
         if not await self._send_start_media(event.chat_id, text, rows):
             await self._reply(event, text, rows)
@@ -756,6 +796,15 @@ class App:
                     raise
                 await self._pause(exc.seconds + 1)
 
+    async def _look_up(self, chat_id: int, items: List[SeqItem]) -> List[Any]:
+        """The messages behind ``items``, in that order (``None`` for one that is gone or could not be looked up)."""
+        try:
+            found = list(await self.client.get_messages(chat_id, ids=[i.msg_id for i in items]))
+        except Exception:  # noqa: BLE001
+            log.exception("could not look up %d files to sort", len(items))
+            found = []
+        return found + [None] * (len(items) - len(found))
+
     async def _run_sort(self, uid: int, chat_id: int) -> None:
         say = lambda text, **kw: self.client.send_message(chat_id, text, parse_mode="html", link_preview=False, **kw)  # noqa: E731
         if uid in self._sorting:
@@ -776,17 +825,19 @@ class App:
             s = await self.db.get_settings(uid)
             plan = analyse(state.items, s["mode"])
             status = await say(f"🔢 <b>Sorting {total} file{'s' if total != 1 else ''}…</b>")
-            fetched = list(await self.client.get_messages(chat_id, ids=[i.msg_id for i in plan.ordered]))
-            fetched += [None] * (len(plan.ordered) - len(fetched))
 
             sent = 0
             failed: List[SeqItem] = []
             note = ""
             stopped = False
-            for index, (item, msg) in enumerate(zip(plan.ordered, fetched)):
+            found: List[Any] = []  # the messages of the files being sent, looked up SORT_LOOKUP at a time as the sort goes
+            for index, item in enumerate(plan.ordered):
                 if cancel.is_set():
                     stopped = True
                     break
+                if index % SORT_LOOKUP == 0:
+                    found = await self._look_up(chat_id, plan.ordered[index:index + SORT_LOOKUP])
+                msg = found[index % SORT_LOOKUP]
                 if msg is None or getattr(msg, "file", None) is None:  # deleted since it was sent
                     failed.append(item)
                     continue
@@ -806,8 +857,9 @@ class App:
                         await self.client.edit_message(status, f"🔢 <b>Sorting…</b> {sent} of {total} sent", parse_mode="html")
                     except Exception:  # noqa: BLE001
                         pass
-                if SORT_GAP:
-                    await asyncio.sleep(SORT_GAP)
+                gap = SORT_GAP if sent < SORT_FAST_FILES else SORT_SLOW_GAP
+                if gap:
+                    await self._pause(gap)
             if status is not None:
                 await self._delete_quietly(chat_id, status.id)
             if stopped:
@@ -1500,6 +1552,10 @@ class App:
             await self._cb_format(event, uid, parts)
             return
 
+        if head == "fs":
+            await self._cb_shared(event, uid, parts)
+            return
+
         if head == "rn":
             await self._cb_rename(event, uid, parts)
             return
@@ -1637,7 +1693,7 @@ class App:
         fmt = await self.db.get_format(uid, fid)
         if fmt is None:
             return False
-        text, rows = panels.format_view(fmt)
+        text, rows = panels.format_view(fmt, share_inline=await self._check_inline())
         await self._edit_panel(event, f"{note}\n\n{text}" if note else text, rows)
         return True
 
@@ -1671,6 +1727,18 @@ class App:
             await self.db.set_format_thumb(uid, fid, None)
             await self._show_format(event, uid, fid)
             await event.answer("Thumbnail deleted.")
+        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)
+            try:
+                await event.edit(text, buttons=panels.to_buttons(rows), parse_mode="html")
+            except errors.MessageNotModifiedError:
+                pass
+            except errors.BotInlineDisabledError:  # Telegram refuses it: inline mode is off
+                self._inline_refused()
+                await event.answer(panels.INLINE_OFF, alert=True)
+                return
+            self._inline_on = True
+            await event.answer("Inline mode is on. Tap Share format again.")
         elif action == "del":
             text, rows = panels.format_delete_confirm(fmt)
             await self._edit_panel(event, text, rows)
@@ -1751,7 +1819,7 @@ class App:
         if fmt is None:
             await self._reply(event, msg)
             return
-        text, rows = panels.format_view(fmt)
+        text, rows = panels.format_view(fmt, share_inline=await self._check_inline())
         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:
@@ -1759,6 +1827,118 @@ class App:
         except Exception:  # noqa: BLE001
             await self._reply(event, full, rows)
 
+    # ------------------------------------------------------------ sharing a format
+    async def _check_inline(self, *, force: bool = False) -> bool:
+        """Is inline mode on for the bot (@BotFather ▸ Bot Settings ▸ Inline Mode)?
+
+        The Share format button needs it: while it is off, Telegram refuses a message that carries that button.  Once it has
+        been seen on it stays on (until Telegram refuses a button); while it is off the bot looks again after
+        ``INLINE_RECHECK`` seconds, or at once with ``force``.
+        """
+        now = time.monotonic()
+        if not force:
+            if self._inline_on:
+                return True
+            if self._inline_checked is not None and now - self._inline_checked < INLINE_RECHECK:
+                return False
+        self._inline_checked = now
+        try:
+            me = await self.client.get_me()
+        except Exception as exc:  # noqa: BLE001
+            log.warning("could not read the bot's profile to see whether inline mode is on: %s", exc)
+            return self._inline_on
+        self._username = getattr(me, "username", None) or self._username
+        # the placeholder is only there while inline mode is on ("" = on, without a placeholder text)
+        self._inline_on = self._inline_on or getattr(me, "bot_inline_placeholder", None) is not None
+        return self._inline_on
+
+    def _inline_refused(self) -> None:
+        """Telegram refused a Share button, so inline mode is off: the next look at the bot's profile is a minute away."""
+        self._inline_on = False
+        self._inline_checked = time.monotonic()
+
+    async def _bot_username(self) -> Optional[str]:
+        if self._username is None:
+            await self._check_inline(force=True)
+        return self._username
+
+    async def on_inline(self, event: Any) -> None:
+        """Where the chat picker of a Share format button ends up: the owner of the format gets a card to send to that chat."""
+        results: List[Any] = []
+        match = SHARE_QUERY.fullmatch((event.text or "").strip())
+        if match:
+            try:
+                results = await self._share_cards(event.sender_id, int(match.group(1)), event.builder)
+            except Exception:  # noqa: BLE001
+                log.exception("Error making the card of a shared format:")
+        await self._answer_inline(event, results)
+
+    async def _share_cards(self, uid: int, fid: int, builder: Any) -> List[Any]:
+        """The card for one of the user's formats: its name, and a button that opens it in this bot (``/start fmt_<token>``)."""
+        fmt = await self.db.get_format(uid, fid)
+        token = await self.db.share_token(uid, fid) if fmt is not None else None
+        username = await self._bot_username() if token else None
+        if fmt is None or token is None or not username:
+            return []
+        title, description, text = panels.share_card(fmt)
+        link = f"https://t.me/{username}?start={SHARE_PREFIX}{token}"
+        card = await builder.article(
+            title, description=description, text=text, parse_mode="html", link_preview=False,
+            buttons=[[Button.url("👁 View format", link)]],
+        )
+        return [card]
+
+    @staticmethod
+    async def _answer_inline(event: Any, results: List[Any]) -> None:
+        try:
+            await event.answer(results, cache_time=0, private=True)  # not cached: the card has to show the format as it is now
+        except Exception as exc:  # noqa: BLE001 - e.g. the query is too old by now
+            log.debug("could not answer an inline query: %s", exc)
+
+    async def _open_shared(self, event: Any, token: str) -> None:
+        """``/start fmt_<token>``: what is in a format somebody shared, with a button to add it to your own formats."""
+        shared = await self.db.get_shared_format(token) if SHARE_TOKEN.fullmatch(token) else None
+        if shared is None:
+            await self._reply(event, panels.SHARE_GONE, [[("✖ Close", "x:close")]])
+            return
+        owner_id, fmt = shared
+        text, rows = panels.shared_format(fmt, token, mine=owner_id == event.sender_id)
+        thumb = await self.db.get_format_thumb(owner_id, fmt["id"]) if fmt["has_thumb"] else None
+        if thumb:  # the format's thumbnail on top, its details as the caption
+            bio = io.BytesIO(thumb)
+            bio.name = "thumbnail.jpg"
+            try:
+                await self.client.send_file(event.chat_id, bio, caption=text, buttons=panels.to_buttons(rows), parse_mode="html")
+                return
+            except Exception as exc:  # noqa: BLE001
+                log.warning("could not send the thumbnail of a shared format (%s); showing its details only", exc)
+        await self._reply(event, text, rows)
+
+    async def _cb_shared(self, event: Any, uid: int, parts: List[str]) -> None:
+        """The button on a shared format: put a copy of it in the user's own formats."""
+        token = parts[2] if len(parts) > 2 else ""
+        shared = await self.db.get_shared_format(token) if SHARE_TOKEN.fullmatch(token) else None
+        mine = None
+        if shared is not None:
+            if parts[1:2] != ["add"]:
+                await event.answer()
+                return
+            if shared[0] == uid:
+                await event.answer("That's your own format.", alert=True)
+                return
+            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)
+                return
+        if mine is None:  # the owner deleted it after sharing
+            await self._edit_panel(event, panels.SHARE_GONE, [[("✖ Close", "x:close")]])
+            await event.answer("That shared format isn't available anymore.", alert=True)
+            return
+        text, rows = panels.shared_added(mine)
+        await self._edit_panel(event, text, rows)
+        await event.answer("Added to your formats.")
+
     # ---------------------------------------------------------- /rename picker
     async def _cb_rename(self, event: Any, uid: int, parts: List[str]) -> None:
         self.pending.pop(uid, None)

bot/db.py

@@ -8,11 +8,12 @@ from __future__ import annotations
 import copy
 import json
 import os
+import secrets
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from sqlalchemy import BigInteger, DateTime, Integer, LargeBinary, String, Text, func, select
+from sqlalchemy import BigInteger, DateTime, Integer, LargeBinary, String, Text, delete, func, select
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
@@ -24,7 +25,7 @@ from .parser import DEFAULT_TEMPLATE
 DEFAULT_SETTINGS: Dict[str, Any] = {
     "mode": "filename",  # filename | caption
     "template": DEFAULT_TEMPLATE,
-    "caption": "{filename}",
+    "caption": "<b>{filename}</b>",
     "file_type": "same",  # same | document | video | audio
     "remove_words": [],
     "metadata_on": False,
@@ -35,6 +36,10 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
 }
 
 
+# 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, caption, file type, ...) comes from the user's settings
 DEFAULT_FORMAT: Dict[str, Any] = {
@@ -85,6 +90,21 @@ class Format(Base):
     created: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
 
 
+class FormatShare(Base):
+    """What a "Share format" card links to: one of a user's formats, opened with a hard-to-guess token.
+
+    A table of its own (not a column on ``rename_formats``): create_all() creates missing tables but never alters existing
+    ones, so a new column would be missing from every database that already has the table.
+    """
+
+    __tablename__ = "rename_format_shares"
+
+    token: Mapped[str] = mapped_column(String(32), primary_key=True)
+    user_id: Mapped[int] = mapped_column(BigInteger, index=True)  # whose format it is
+    fmt_id: Mapped[int] = mapped_column(Integer, index=True)
+    created: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
+
+
 class KV(Base):
     __tablename__ = "kv"
 
@@ -142,6 +162,20 @@ def _format_dict(fid: int, name: str, raw: Optional[str], has_thumb: bool) -> Di
     return out
 
 
+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}
+    if name.casefold() not in used:
+        return name
+    number = 2
+    while True:  # at most MAX_FORMATS names exist, so a free one turns up quickly
+        suffix = f" ({number})"
+        candidate = name[: max(1, name_max - len(suffix))].rstrip() + suffix
+        if candidate.casefold() not in used:
+            return candidate
+        number += 1
+
+
 class Database:
     def __init__(self, url: str):
         self.url, connect_args = normalize_database_url(url)
@@ -157,6 +191,23 @@ class Database:
     async def init(self) -> None:
         async with self.engine.begin() as conn:
             await conn.run_sync(Base.metadata.create_all)
+        await self._migrate()
+
+    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
+        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)
+            await session.commit()
+        await self.kv_set(BOLD_CAPTION_MIGRATION, "done")
 
     async def close(self) -> None:
         await self.engine.dispose()
@@ -321,9 +372,66 @@ class Database:
             if row is None or row.user_id != uid:
                 return False
             await session.delete(row)
+            await session.execute(delete(FormatShare).where(FormatShare.user_id == uid, FormatShare.fmt_id == fid))  # its links die with it
             await session.commit()
             return True
 
+    # ----- sharing a format ------------------------------------------------------------
+    async def share_token(self, uid: int, fid: int) -> Optional[str]:
+        """The token that opens the user's format for others (made the first time, the same afterwards); ``None`` if there is no such format."""
+        async with self._sessions() as session:
+            if (await session.execute(select(Format.id).where(Format.id == fid, Format.user_id == uid))).first() is None:
+                return None
+            existing = (
+                await session.execute(
+                    select(FormatShare.token)
+                    .where(FormatShare.user_id == uid, FormatShare.fmt_id == fid)
+                    .order_by(FormatShare.created)
+                    .limit(1)
+                )
+            ).scalar()
+            if existing:
+                return str(existing)
+            token = secrets.token_urlsafe(12)
+            session.add(FormatShare(token=token, user_id=uid, fmt_id=fid))
+            await session.commit()
+            return token
+
+    async def get_shared_format(self, token: str) -> Optional[Tuple[int, Dict[str, Any]]]:
+        """``(owner's user id, the format as it is now)``; ``None`` for an unknown token or a format that was deleted."""
+        async with self._sessions() as session:
+            share = await session.get(FormatShare, token)
+            if share is None:
+                return None
+            r = (
+                await session.execute(
+                    select(Format.id, Format.name, Format.data, Format.thumb.isnot(None)).where(
+                        Format.id == share.fmt_id, Format.user_id == share.user_id
+                    )
+                )
+            ).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]]:
+        """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``.
+        """
+        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())
+            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)
+            session.add(row)
+            await session.flush()
+            new_id, raw, has_thumb = row.id, source.data, source.thumb is not None
+            await session.commit()
+        return _format_dict(new_id, name, raw, has_thumb)
+
     # ----- admins ------------------------------------------------------------------
     async def list_admins(self) -> List[int]:
         async with self._sessions() as session:

bot/errorlog.py

@@ -43,6 +43,8 @@ def describe_update(event: Any) -> str:
         if data is not None:
             parts.append(f"message_id={getattr(event, 'message_id', None)}")
             parts.append("data=" + repr(bytes(data).decode("utf-8", "replace")))
+        elif hasattr(event, "builder"):  # an inline query: what was typed after the bot's name
+            parts.append("query=" + repr(clip(getattr(event, "text", "") or "", 100)))
         else:
             parts.append(f"message_id={getattr(event, 'id', None)}")
             text = getattr(event, "raw_text", None)

bot/panels.py

@@ -22,10 +22,29 @@ 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
 
 
+INLINE = "inline:"  # a button whose data starts with this opens Telegram's chat picker, with "@bot <the rest>" typed in the chat
+
+
+def share_query(fid: int) -> str:
+    """The inline query a Share format button types into the chosen chat (``App.on_inline`` answers it with a card)."""
+    return f"share_{fid}"
+
+
 def to_buttons(rows: Sequence[Row]):
     from telethon.tl.custom import Button
 
-    return [[Button.inline(label, data.encode()) for label, data in row] for row in rows]
+    def button(label: str, data: str):
+        if data.startswith(INLINE):
+            return Button.switch_inline(label, query=data[len(INLINE):], same_peer=False)
+        return Button.inline(label, data.encode())
+
+    return [[button(label, data) for label, data in row] for row in rows]
+
+
+def without_inline(rows: Sequence[Row]) -> List[Row]:
+    """The rows with every Share format button turned into the plain one that explains how to switch inline mode on."""
+    prefix = INLINE + "share_"
+    return [[(label, "fm:sh:" + data[len(prefix):] if data.startswith(prefix) else data) for label, data in row] for row in rows]
 
 
 def nav(back: str = "", *, home: bool = True) -> List[Row]:
@@ -188,7 +207,7 @@ 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, thumbnail, metadata, tracks); "
+        "2. /formats — save up to 12 named formats (template, 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"
@@ -262,18 +281,25 @@ def formats_menu(formats: Sequence[Dict[str, Any]], limit: int) -> Panel:
     return text, rows + nav("home")
 
 
-def format_view(fmt: Dict[str, Any]) -> Panel:
+def _format_lines(fmt: Dict[str, Any], *, thumb_yes: str, thumb_no: str) -> List[str]:
+    """What a format holds, one line per field."""
     m = fmt["meta"]
     lines = [
-        f"<b>🗂 {esc(clip(fmt['name'], 30))}</b>",
-        "",
         f"{DOT} <b>Template</b> ▸ {_code(fmt['template'], 60)}",
-        f"{DOT} <b>Thumbnail</b> ▸ " + ("✅ saved" if fmt.get("has_thumb") else "— (your default thumbnail is used)"),
+        f"{DOT} <b>Thumbnail</b> ▸ " + (thumb_yes if fmt.get("has_thumb") else thumb_no),
     ]
     for key, label in FORMAT_FIELD_LABELS:
         lines.append(f"{DOT} <b>{label}</b> ▸ {_code(m.get(key, ''), 50)}")
     lines.append(f"{DOT} <b>Keep Audio</b> ▸ {esc(clip(fmt_tokens(fmt['keep_audio']), 50))}")
     lines.append(f"{DOT} <b>Keep Subtitle</b> ▸ {esc(clip(fmt_tokens(fmt['keep_subtitle']), 50))}")
+    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, caption, file type and the rest come from your normal settings."]
     fid = fmt["id"]
     thumb_row: Row = [("Thumbnail", f"fm:th:{fid}")]
@@ -285,11 +311,44 @@ def format_view(fmt: Dict[str, Any]) -> 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")],
+        [("📤 Share format", INLINE + share_query(fid) if share_inline else f"fm:sh:{fid}")],
         [("🗑 Delete format", f"fm:del:{fid}")],
     ] + nav("formats")
     return "\n".join(lines), rows
 
 
+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 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)
+    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.",
+    )
+
+
+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)")
+    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."]
+        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."
+    return text, [[("🗂 Open format", f"fm:v:{fmt['id']}")], [("✖ Close", "x:close")]]
+
+
 def format_delete_confirm(fmt: Dict[str, Any]) -> Panel:
     text = f"<b>Delete the format “{esc(clip(fmt['name'], 30))}”?</b>\n\nIts template, thumbnail and metadata are removed. This can't be undone."
     return text, [[("🗑 Yes, delete", f"fm:ok:{fmt['id']}"), ("◀ Keep it", f"fm:v:{fmt['id']}")]]

tests/test_app.py

@@ -640,7 +640,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}")
     cb = await click(ctx, OWNER, "clr:caption")
-    assert (await prefs(ctx))["caption"] == "{filename}" and "CAPTION" in cb.edits[-1][0]
+    assert (await prefs(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")

tests/test_db.py

@@ -93,6 +93,7 @@ async def test_a_foreign_table_called_formats_in_a_shared_database_is_left_alone
         created = await database.create_format(1, "One Piece", "{title} E{episode}")
         assert [f["name"] for f in await database.list_formats(1)] == ["One Piece"]
         assert (await database.get_format(1, created["id"]))["template"] == "{title} E{episode}"
+        assert await database.share_token(1, created["id"])  # the sharing table is ours too
         assert await database.delete_format(1, created["id"]) is True
     finally:
         await database.close()
@@ -112,3 +113,109 @@ async def test_first_use_by_many_concurrent_handlers_does_not_collide(db):
     # the same goes for the other writers that create the row on first use
     await asyncio.gather(*(db.record_job(78, 10) for _ in range(5)), *(db.set_thumb(79, b"x") for _ in range(5)))
     assert await db.count_users() == 3
+
+
+# ---------------------------------------------------------------------------
+# bold captions
+# ---------------------------------------------------------------------------
+
+
+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>"
+
+
+async def test_the_plain_default_caption_of_earlier_versions_becomes_bold_once(db):
+    import json
+
+    from bot.db import BOLD_CAPTION_MIGRATION, User
+
+    # what an older version left behind: no marker yet, and the settings stored in full
+    await db.kv_delete(BOLD_CAPTION_MIGRATION)
+    stored = {
+        1: {"caption": "{filename}", "mode": "caption", "template": "T {title}"},  # still the old default
+        2: {"caption": "{filename} · {size}"},  # their own caption
+        3: {"mode": "caption"},  # no caption stored: gets the default
+        4: "not json",
+        5: [1, 2],
+    }
+    async with db._sessions() as session:
+        for uid, value in stored.items():
+            session.add(User(id=uid, settings=value if isinstance(value, str) else json.dumps(value)))
+        await session.commit()
+
+    await db.init()  # runs the migration
+    fresh = Database(db.url)  # a new instance has no cache
+    try:
+        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 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...
+    finally:
+        await fresh.close()
+    await db.init()
+    again = Database(db.url)
+    try:
+        assert (await again.get_settings(1))["caption"] == "{filename}"  # ...sticks, also across restarts
+    finally:
+        await again.close()
+
+
+# ---------------------------------------------------------------------------
+# sharing formats
+# ---------------------------------------------------------------------------
+
+
+async def test_share_token_is_stable_private_to_the_owner_and_dies_with_the_format(db):
+    fmt = await db.create_format(1, "One Piece", "E{episode}")
+    token = await db.share_token(1, fmt["id"])
+    assert token and len(token) >= 16 and token == await db.share_token(1, fmt["id"])
+    other = await db.create_format(1, "Dragon Ball")
+    assert await db.share_token(1, other["id"]) != token
+    assert await db.share_token(2, fmt["id"]) is None and await db.share_token(1, 999) is None
+
+    owner, shared = await db.get_shared_format(token)
+    assert owner == 1 and shared["name"] == "One Piece" and shared["template"] == "E{episode}"
+    await db.update_format(1, fmt["id"], template="New {title}")
+    assert (await db.get_shared_format(token))[1]["template"] == "New {title}"  # the format as it is now
+    assert await db.get_shared_format("nope") is None
+
+    assert await db.delete_format(1, fmt["id"]) is True
+    assert await db.get_shared_format(token) is None
+    await db.create_format(1, "Another")  # it may get the deleted format's id: the old link must not lead to it
+    assert await db.get_shared_format(token) is None
+    assert await db.get_shared_format(await db.share_token(1, other["id"])) is not None  # the other link is untouched
+
+
+async def test_copy_format_copies_everything_and_finds_a_free_name(db):
+    src = await db.create_format(1, "One Piece", "E{episode}")
+    await db.update_format(1, src["id"], meta={"title": "OP"}, keep_audio=["japanese"], keep_subtitle=["2"])
+    await db.set_format_thumb(1, src["id"], b"\xff\xd8thumb")
+
+    mine = await db.copy_format(2, 1, src["id"])
+    assert mine["name"] == "One Piece" and mine["template"] == "E{episode}" and mine["meta"]["title"] == "OP"
+    assert mine["keep_audio"] == ["japanese"] and mine["keep_subtitle"] == ["2"] and mine["has_thumb"] is True
+    assert mine["id"] != src["id"] and await db.get_format_thumb(2, mine["id"]) == b"\xff\xd8thumb"
+    assert [(await db.copy_format(2, 1, src["id"]))["name"] for _ in range(2)] == ["One Piece (2)", "One Piece (3)"]
+
+    await db.update_format(2, mine["id"], template="Changed")  # the copy is independent of the original
+    assert (await db.get_format(1, src["id"]))["template"] == "E{episode}"
+    assert await db.copy_format(2, 3, src["id"]) is None and await db.copy_format(2, 1, 999) is None  # not theirs / gone
+
+    big = await db.create_format(1, "N" * 30)
+    names = [(await db.copy_format(3, 1, big["id"], name_max=30))["name"] for _ in range(2)]
+    assert names == ["N" * 30, "N" * 26 + " (2)"]  # the number fits inside the length limit
+
+
+async def test_copy_format_stops_at_the_limit(db):
+    from bot.db import MAX_FORMATS
+    from bot.errors import FormatError
+
+    src = await db.create_format(1, "One Piece")
+    for i in range(MAX_FORMATS):
+        await db.create_format(2, f"F{i}")
+    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

tests/test_errorlog.py

@@ -13,7 +13,7 @@ from bot import errorlog
 from bot.config import load_config
 from bot.errorlog import ChannelLogHandler, ErrorReporter, build_report, describe_update, redact
 
-from .tgfakes import FakeCallback, FakeEvent, document_message
+from .tgfakes import FakeCallback, FakeEvent, FakeInlineQuery, document_message
 
 CODE = '<pre><code class="language-python">'
 
@@ -102,6 +102,12 @@ def test_real_telethon_events_are_described_too():
     )
 
 
+async def test_an_inline_query_is_described_with_what_was_typed():
+    assert describe_update(FakeInlineQuery(5, "share_12")) == "FakeInlineQuery(sender_id=5, chat_id=5, query='share_12')"
+    query = types.UpdateBotInlineQuery(query_id=1, user_id=77, query="share_12", offset="")
+    assert describe_update(events.InlineQuery.Event(query)) == "InlineQuery(sender_id=77, chat_id=77, query='share_12')"
+
+
 def test_a_long_text_is_cut_and_an_odd_object_never_raises():
     line = describe_update(FakeEvent(1, "x" * 500))
     assert "…" in line and len(line) < 400

tests/test_formats_app.py

@@ -424,8 +424,11 @@ def test_the_format_screens_fit_in_a_caption_even_with_the_longest_values():
     }
     formats = [dict(fmt, id=i, name="F" * 30) for i in range(12)]
     for name, (text, rows) in {
-        "view": panels.format_view(fmt), "menu": panels.formats_menu(formats, 12), "delete": panels.format_delete_confirm(fmt),
+        "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),
         "ready": panels.rename_ready(fmt, 10), "picker": panels.rename_picker(formats),
+        "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},
     }.items():
         assert len(visible(text)) <= CAPTION_LIMIT, (name, len(visible(text)))

tests/test_panels.py

@@ -4,8 +4,10 @@ import re
 
 import pytest
 
+from telethon.tl import types
+
 from bot import panels
-from bot.app import BACK, PANEL_NAMES
+from bot.app import BACK, PANEL_NAMES, SHARE_QUERY
 from bot.db import DEFAULT_SETTINGS
 from bot.media import LANGUAGES
 from bot.utils import code_each
@@ -98,6 +100,48 @@ 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}",
+           "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]
+    off = [d for row in panels.format_view(fmt, share_inline=False)[1] for _l, d in row]
+    assert "inline:share_12" in on and "fm:sh:12" not in on
+    assert "fm:sh:12" in off and not any(d.startswith("inline:") for d in off)
+    assert panels.format_view(fmt)[1] == panels.format_view(fmt, share_inline=False)[1]  # the safe one is the default
+    assert SHARE_QUERY.fullmatch(panels.share_query(12))  # what the bot listens for is what the button types
+
+
+def test_without_inline_swaps_only_the_share_buttons():
+    rows = panels.format_view(sample_format(), share_inline=True)[1]
+    assert panels.without_inline(rows) == panels.format_view(sample_format(), share_inline=False)[1]
+    assert panels.without_inline([[("A", "a:1"), ("B", "in:thing")]]) == [[("A", "a:1"), ("B", "in:thing")]]
+    assert panels.without_inline([]) == []
+
+
+def test_inline_rows_become_share_buttons_and_the_rest_stay_callbacks():
+    (row,) = panels.to_buttons([[("📤 Share", "inline:share_7"), ("Go", "a:1")]])
+    assert isinstance(row[0].type, types.InlineButtonTypeSwitchInline)
+    assert row[0].type.query == "share_7" and row[0].type.same_peer is False  # any chat can be picked
+    assert isinstance(row[1].type, types.InlineButtonTypeCallback) and row[1].type.data == b"a:1"
+
+
+def test_the_shared_format_page_and_card():
+    fmt = sample_format(meta={"title": "<One Piece>", "author": "", "artist": "", "audio": "", "subtitle": "", "video": ""}, has_thumb=True)
+    text, rows = panels.shared_format(fmt, "tok_en-1")
+    assert "<b>📦 One Piece</b>" in text and "✅ included" in text and "&lt;One Piece&gt;" in text
+    assert rows == [[("➕ Add to my formats", "fs:add:tok_en-1")], [("✖ Close", "x:close")]]
+    text, rows = panels.shared_format(fmt, "tok_en-1", mine=True)
+    assert "your own format" in text and rows == [[("🗂 Open format", "fm:v:12")], [("✖ Close", "x:close")]]
+    title, description, card = panels.share_card(sample_format(name="A & B"))
+    assert title == "🗂 A & B" and "A &amp; B" in card and "<b>" in card and description
+
+
 def test_every_input_button_has_a_prompt_and_a_back_target():
     assert set(panels.PROMPTS) == set(BACK)
     assert set(BACK.values()) <= PANEL_NAMES

tests/test_pipeline.py

@@ -100,7 +100,7 @@ async def test_plain_rename_sends_video_with_thumbnail(env):
     assert (video.w, video.h) == (320, 240) and 1 < video.duration < 3 and video.supports_streaming
     assert kw["force_document"] is False and kw["mime_type"] == "video/x-matroska"
     assert kw["thumb"][:2] == b"\xff\xd8"  # generated from a video frame
-    assert kw["caption"] == "[S01E05] Tokyo Revengers [1080p]"
+    assert kw["caption"] == "<b>[S01E05] Tokyo Revengers [1080p]</b>" and kw["parse_mode"] == "html"  # bold, by default
     assert input_file.name == job.new_name
     assert client.uploads[0].read_bytes() == (env.media_dir / "sample.mkv").read_bytes()  # untouched without metadata
     assert "Done" in client.edits[-1][0] and client.edits[-1][1] is None

tests/test_sequence_app.py

@@ -16,6 +16,7 @@ OP = "{n} - One Piece [Dual] 720p @Anime_X_Universe.mkv"
 def quick(monkeypatch):
     monkeypatch.setattr(appmod, "SEQUENCE_STATUS_DELAY", 0.02)
     monkeypatch.setattr(appmod, "SORT_GAP", 0)
+    monkeypatch.setattr(appmod, "SORT_SLOW_GAP", 0)
 
 
 async def settle(delay=0.12):
@@ -95,6 +96,19 @@ async def test_the_limit_is_announced_once_and_extra_files_are_ignored(ctx, monk
     assert "3 files collected" in texts(ctx)[-1] and "most I can sort" in texts(ctx)[-1]
 
 
+async def test_a_thousand_files_can_be_collected_and_the_next_one_is_refused(ctx):
+    assert appmod.SEQUENCE_MAX == 1000
+    ev = await say(ctx, OWNER, "/sequence")
+    assert "up to 1000" in ev.texts[0]
+    replies = []
+    for k in range(1001):
+        replies += (await send_doc(ctx, OWNER, OP.format(n=k + 1), mid=100 + k)).texts
+    assert len(ctx.app.modes[OWNER].data.items) == 1000
+    assert len(replies) == 1 and "limit: 1000 files" in replies[0]
+    await settle()
+    assert "1000 files collected" in texts(ctx)[-1] and "most I can sort at once (1000)" in texts(ctx)[-1]
+
+
 async def test_every_user_has_their_own_sequence(ctx):
     await say(ctx, OWNER, "/sequence")
     await say(ctx, ADMIN_CFG, "/sequence")
@@ -168,6 +182,53 @@ async def test_sort_fetches_the_messages_again_so_old_file_references_still_work
     assert chat == OWNER and sorted(ids) == [100, 101, 102] and ids == [101, 100, 102]
 
 
+async def test_sort_looks_the_files_up_a_hundred_at_a_time_and_keeps_the_order(ctx):
+    # One request for more than 300 ids makes Telethon wait 10 s between its chunks of 100: with a thousand files that is
+    # a minute and a half of nothing before the first file arrives.  Looking them up as the sort goes avoids it.
+    await say(ctx, OWNER, "/sequence")
+    at = await feed(ctx, range(250, 0, -1))  # newest first; at[episode] is its message id
+    await say(ctx, OWNER, "/sort")
+    assert sent_ids(ctx) == [at[n] for n in range(1, 251)]
+    assert [len(asked) for _chat, asked in ctx.client.get_calls] == [100, 100, 50]
+    assert [asked[0] for _chat, asked in ctx.client.get_calls] == [at[1], at[101], at[201]]
+    assert "Sorted 250 files" in last_text(ctx) and "E01 → E250" in last_text(ctx) and "No missing or repeated" in last_text(ctx)
+
+
+async def test_lookups_follow_the_sending_instead_of_all_coming_first(ctx):
+    await say(ctx, OWNER, "/sequence")
+    await feed(ctx, range(1, 151))
+    sent_so_far = []
+    original = ctx.client.get_messages
+
+    async def lookup(entity, ids=None, **kw):
+        sent_so_far.append(len(ctx.client.files))
+        return await original(entity, ids=ids, **kw)
+
+    ctx.client.get_messages = lookup
+    await say(ctx, OWNER, "/sort")
+    assert sent_so_far == [0, 100]  # the second hundred is looked up once the first hundred is out
+
+
+async def test_a_chunk_that_cannot_be_looked_up_is_listed_and_the_rest_still_arrives(ctx, caplog):
+    await say(ctx, OWNER, "/sequence")
+    at = await feed(ctx, range(1, 251))
+    original = ctx.client.get_messages
+
+    async def flaky(entity, ids=None, **kw):
+        if ids[0] == at[101]:  # the second chunk: episodes 101-200
+            raise RuntimeError("MESSAGE_ID_INVALID")
+        return await original(entity, ids=ids, **kw)
+
+    ctx.client.get_messages = flaky
+    with caplog.at_level("ERROR"):
+        await say(ctx, OWNER, "/sort")
+    assert sent_ids(ctx) == [at[n] for n in (*range(1, 101), *range(201, 251))]
+    report = last_text(ctx)
+    assert "Sorted 150 of 250 files" in report and "Couldn't be sent" in report and "… and 88 more" in report
+    assert any("could not look up 100 files" in r.getMessage() for r in caplog.records)  # the log channel hears about it
+    assert OWNER not in ctx.app._sorting
+
+
 async def test_the_rename_mode_decides_where_the_episode_is_read_from(ctx):
     await say(ctx, OWNER, "/mode caption")
     await say(ctx, OWNER, "/sequence")
@@ -342,6 +403,23 @@ async def test_a_short_flood_wait_is_waited_out_and_the_file_is_sent_again(ctx):
     assert "Sorted 3 files" in last_text(ctx) and "Couldn't be sent" not in last_text(ctx)
 
 
+async def test_a_long_batch_goes_at_about_one_file_a_second_after_the_first_ones(ctx, monkeypatch):
+    monkeypatch.setattr(appmod, "SORT_GAP", 0.1)
+    monkeypatch.setattr(appmod, "SORT_SLOW_GAP", 0.5)
+    monkeypatch.setattr(appmod, "SORT_FAST_FILES", 3)
+    paused = []
+
+    async def pause(seconds):
+        paused.append(seconds)
+
+    ctx.app._pause = pause
+    await say(ctx, OWNER, "/sequence")
+    await feed(ctx, range(1, 7))
+    await say(ctx, OWNER, "/sort")
+    assert paused == [0.1, 0.1, 0.5, 0.5, 0.5, 0.5]  # files 2 and 3 follow quickly, the rest wait their turn
+    assert "Sorted 6 files" in last_text(ctx)
+
+
 async def test_a_very_long_flood_wait_stops_the_sort_and_lists_what_was_not_sent(ctx):
     await say(ctx, OWNER, "/sequence")
     await feed(ctx, (4, 3, 2, 1))
@@ -394,7 +472,25 @@ async def test_a_file_deleted_before_sorting_is_listed_not_fatal(ctx):
     assert OWNER not in ctx.app._sorting
 
 
-async def test_sort_that_blows_up_does_not_leave_the_user_locked_out(ctx):
+async def test_sort_that_blows_up_does_not_leave_the_user_locked_out(ctx, monkeypatch):
+    await say(ctx, OWNER, "/sequence")
+    await feed(ctx, (2, 1))
+
+    def boom(*a, **kw):
+        raise RuntimeError("something nobody expected")
+
+    original = appmod.analyse
+    monkeypatch.setattr(appmod, "analyse", boom)
+    ev = await say(ctx, OWNER, "/sort")
+    assert "Something went wrong" in ev.texts[-1] and OWNER not in ctx.app._sorting
+    monkeypatch.setattr(appmod, "analyse", original)
+    await say(ctx, OWNER, "/sequence")
+    await feed(ctx, (1,), first_id=300)
+    await say(ctx, OWNER, "/sort")
+    assert sent_ids(ctx) == [300]
+
+
+async def test_when_telegram_cannot_look_the_files_up_the_user_gets_a_report_and_is_not_locked_out(ctx):
     await say(ctx, OWNER, "/sequence")
     await feed(ctx, (2, 1))
 
@@ -402,8 +498,10 @@ async def test_sort_that_blows_up_does_not_leave_the_user_locked_out(ctx):
         raise RuntimeError("telegram is down")
 
     original, ctx.client.get_messages = ctx.client.get_messages, boom
-    ev = await say(ctx, OWNER, "/sort")
-    assert "Something went wrong" in ev.texts[-1] and OWNER not in ctx.app._sorting
+    await say(ctx, OWNER, "/sort")
+    assert ctx.client.files == [] and OWNER not in ctx.app._sorting
+    report = last_text(ctx)
+    assert "Sorted 0 of 2 files" in report and "Couldn't be sent" in report and "1 - One Piece" in report
     ctx.client.get_messages = original
     await say(ctx, OWNER, "/sequence")
     await feed(ctx, (1,), first_id=300)

tests/test_settings_ops.py

@@ -49,7 +49,7 @@ async def test_caption_set_validate_reset(db):
     ok, msg = await apply_setting(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"] == "{filename}"
+    assert ok and (await get(db))["caption"] == "<b>{filename}</b>"
 
 
 async def test_remove_words(db):

tests/test_share_app.py

@@ -0,0 +1,349 @@
+"""Sharing a format: the Share format button, the card it sends to a chat, the page that opens, and Add to my formats."""
+import logging
+
+from sqlalchemy import func, select
+from telethon import TelegramClient
+from telethon.sessions import StringSession
+from telethon.tl import types
+
+from bot import app as appmod
+from bot import panels
+from bot.db import MAX_FORMATS, FormatShare
+
+from .appkit import ADMIN_CFG, LOG, OWNER, STRANGER, click, data_of, jpeg, say
+from .test_formats_app import make_format
+from .tgfakes import FakeInlineQuery, dispatch
+
+
+async def share_count(ctx):
+    async with ctx.db._sessions() as session:
+        return (await session.execute(select(func.count()).select_from(FormatShare))).scalar()
+
+
+async def ask(ctx, sender, text):
+    """Somebody types ``@bot <text>`` in a chat."""
+    query = FakeInlineQuery(sender, text)
+    await dispatch(ctx.client, query)
+    return query
+
+
+async def share(ctx, name="One Piece", **changes):
+    fmt = await make_format(ctx, name, **changes)
+    return fmt, await ctx.db.share_token(OWNER, fmt["id"])
+
+
+def share_buttons(buttons):
+    return [b for row in buttons for b in row if b.text == "📤 Share format"]
+
+
+# ---------------------------------------------------------------------------
+# the Share format button
+# ---------------------------------------------------------------------------
+
+
+async def test_the_format_screen_has_a_share_button_that_opens_the_chat_picker(ctx):
+    fmt = await make_format(ctx)
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    (button,) = share_buttons(cb.edits[-1][1])
+    assert isinstance(button.type, types.InlineButtonTypeSwitchInline)
+    assert button.type.query == f"share_{fmt['id']}" and button.type.same_peer is False  # pick any chat
+    assert appmod.SHARE_QUERY.fullmatch(button.type.query)
+    data = data_of(cb.edits[-1][1])
+    assert data.index(f"inline:share_{fmt['id']}") < data.index(f"fm:del:{fmt['id']}")  # right above Delete
+
+
+async def test_the_share_button_is_a_valid_telegram_button():
+    """The format screen's rows go through Telethon's own conversion and serialise (no network needed)."""
+    fmt = {"id": 12, "name": "One Piece", "has_thumb": False, "template": "{title}", "meta": {k: "" for k in ("title", "author", "artist", "audio", "subtitle", "video")},
+           "keep_audio": [], "keep_subtitle": []}
+    _text, rows = panels.format_view(fmt, share_inline=True)
+    client = TelegramClient(StringSession(), 1, "0123456789abcdef0123456789abcdef")
+    markup = client.build_reply_markup(panels.to_buttons(rows))
+    assert bytes(markup)
+    kinds = [type(b.type).__name__ for row in markup.rows for b in row.buttons]
+    assert kinds.count("InlineButtonTypeSwitchInline") == 1 and kinds.count("InlineButtonTypeCallback") == len(kinds) - 1
+
+
+async def test_without_inline_mode_the_share_button_explains_how_to_turn_it_on(ctx):
+    ctx.client.inline_placeholder, ctx.client.server_inline = None, False
+    fmt = await make_format(ctx)
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")  # the screen still works
+    data = data_of(cb.edits[-1][1])
+    assert f"fm:sh:{fmt['id']}" in data and not any(d.startswith("inline:") for d in data)
+    assert cb.alerts == []
+
+    cb = await click(ctx, OWNER, f"fm:sh:{fmt['id']}")
+    assert cb.alerts == [panels.INLINE_OFF] and "Inline Mode" in cb.alerts[0] and len(cb.alerts[0]) <= 200
+    assert cb.edits == []
+
+
+async def test_turning_inline_mode_on_is_noticed(ctx):
+    ctx.client.inline_placeholder, ctx.client.server_inline = None, False
+    fmt = await make_format(ctx)
+    await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    calls = ctx.client.me_calls
+
+    ctx.client.inline_placeholder, ctx.client.server_inline = "", True  # on, without a placeholder text
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")  # within the minute the bot doesn't ask again
+    assert f"fm:sh:{fmt['id']}" in data_of(cb.edits[-1][1]) and ctx.client.me_calls == calls
+
+    ctx.app._inline_checked -= appmod.INLINE_RECHECK + 1
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert f"inline:share_{fmt['id']}" in data_of(cb.edits[-1][1]) and ctx.client.me_calls == calls + 1
+    await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert ctx.client.me_calls == calls + 1  # on stays on, no more questions
+
+
+async def test_tapping_the_plain_share_button_tries_the_real_one(ctx):
+    """If the profile doesn't say so but Telegram accepts the share button, inline mode is on."""
+    ctx.client.inline_placeholder = None  # the profile says off, the server accepts the button
+    fmt = await make_format(ctx)
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert f"fm:sh:{fmt['id']}" in data_of(cb.edits[-1][1])
+
+    cb = await click(ctx, OWNER, f"fm:sh:{fmt['id']}")
+    assert cb.toasts == ["Inline mode is on. Tap Share format again."]
+    assert f"inline:share_{fmt['id']}" in data_of(cb.edits[-1][1])
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert f"inline:share_{fmt['id']}" in data_of(cb.edits[-1][1])  # remembered
+
+
+async def test_switching_inline_mode_off_later_does_not_break_the_format_screen(ctx):
+    fmt = await make_format(ctx)
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert f"inline:share_{fmt['id']}" in data_of(cb.edits[-1][1])
+
+    ctx.client.inline_placeholder, ctx.client.server_inline = None, False  # switched off in @BotFather meanwhile
+    cb = await click(ctx, OWNER, f"fm:v:{fmt['id']}")
+    assert cb.alerts == [] and f"fm:sh:{fmt['id']}" in data_of(cb.edits[-1][1])  # the plain button instead of an error
+    cb = await click(ctx, OWNER, f"fm:sh:{fmt['id']}")
+    assert cb.alerts == [panels.INLINE_OFF]
+
+
+async def test_a_refused_share_button_is_also_handled_when_the_screen_comes_back_after_a_prompt(ctx):
+    fmt = await make_format(ctx)
+    await click(ctx, OWNER, f"fm:v:{fmt['id']}")  # inline mode is seen on
+    ctx.client.inline_placeholder, ctx.client.server_inline = None, False
+    await click(ctx, OWNER, f"fm:in:{fmt['id']}:title", msg_id=700)
+    ev = await say(ctx, OWNER, "One Piece")
+    assert "Something went wrong" not in "".join(ev.texts)
+    (message,) = [t for t in ev.texts if "🗂 One Piece" in t]  # the screen was sent again, in a new message
+    assert f"fm:sh:{fmt['id']}" in data_of(ev.out[-1][1]) and "Title" in message
+
+
+# ---------------------------------------------------------------------------
+# the card that goes to the chat
+# ---------------------------------------------------------------------------
+
+
+async def test_the_chat_picker_gets_a_card_that_opens_the_format(ctx):
+    fmt = await make_format(ctx, "One Piece")
+    query = await ask(ctx, OWNER, f"share_{fmt['id']}")
+    assert query.answers[-1][1] == {"cache_time": 0, "private": True}
+    (card,) = query.results
+    assert card.type == "article" and card.title == "🗂 One Piece" and card.description == "Tap to send this format to the chat"
+    token = await ctx.db.share_token(OWNER, fmt["id"])
+    message = card.send_message
+    assert "One Piece" in message.message and [type(e).__name__ for e in message.entities] == ["MessageEntityBold"]
+    assert message.no_webpage is True
+    (button,) = [b for row in message.reply_markup.rows for b in row.buttons]
+    assert button.text == "👁 View format" and button.type.url == f"https://t.me/RenameBot?start=fmt_{token}"
+    assert bytes(card)  # a valid Telegram object
+
+    again = await ask(ctx, OWNER, f"share_{fmt['id']}")  # the same link every time
+    assert again.results[0].send_message.reply_markup.rows[0].buttons[0].type.url == button.type.url
+
+
+async def test_the_card_does_not_give_away_what_is_in_the_format(ctx):
+    fmt = await make_format(ctx, "One Piece", meta={"title": "Secret title", "author": "@private"})
+    (card,) = (await ask(ctx, OWNER, f"share_{fmt['id']}")).results
+    assert "Secret title" not in card.send_message.message and "@private" not in card.send_message.message
+    assert "E{episode}" not in card.send_message.message
+
+
+async def test_inline_queries_get_nothing_for_anything_but_the_owners_own_formats(ctx):
+    mine = await make_format(ctx, "Mine")
+    theirs = await make_format(ctx, "Theirs", uid=ADMIN_CFG)
+    for who, text in (
+        (OWNER, "share_999"), (OWNER, f"share_{theirs['id']}"), (OWNER, "hello"), (OWNER, ""), (OWNER, "share_"),
+        (OWNER, f"share_{mine['id']}x"), (OWNER, "share_" + "9" * 30), (ADMIN_CFG, f"share_{mine['id']}"),
+    ):
+        query = await ask(ctx, who, text)
+        assert query.results == [] and len(query.answers) == 1, (who, text)
+    assert await share_count(ctx) == 0  # no link was made for any of them
+
+
+async def test_strangers_get_no_results_and_no_notice(ctx):
+    fmt = await make_format(ctx)
+    query = await ask(ctx, STRANGER, f"share_{fmt['id']}")
+    assert query.results == [] and len(query.answers) == 1
+    assert STRANGER not in ctx.app._warned and not [m for m in ctx.client.sent if m[0] == LOG]  # anyone can type the bot's name
+
+
+async def test_a_failure_making_the_card_still_answers_the_query(ctx, monkeypatch, caplog):
+    fmt = await make_format(ctx)
+
+    async def broken(*_a, **_k):
+        raise RuntimeError("database is down")
+
+    monkeypatch.setattr(ctx.db, "share_token", broken)
+    with caplog.at_level(logging.ERROR):
+        query = await ask(ctx, OWNER, f"share_{fmt['id']}")
+    assert query.results == [] and len(query.answers) == 1
+    assert "Error making the card" in caplog.text
+
+
+# ---------------------------------------------------------------------------
+# opening a shared format
+# ---------------------------------------------------------------------------
+
+
+async def test_opening_a_shared_format_shows_it_and_offers_to_add_it(ctx):
+    fmt, token = await share(ctx, meta={"title": "One Piece", "video": "HD"}, keep_audio=["japanese", "2"])
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{token}")
+    (text,) = ev.texts
+    assert "📦 One Piece" in text and "shared with you" in text and "Main menu" not in text
+    for label in ("Template", "Thumbnail", "Title", "Author", "Artist", "Audio", "Subtitle", "Video", "Keep Audio", "Keep Subtitle"):
+        assert label in text, label
+    assert "One Piece - E{episode}" in text and "<b>Title</b> ▸ <code>One Piece</code>" in text and "Japanese, 2" in text
+    assert data_of(ev.out[0][1]) == [f"fs:add:{token}", "x:close"]
+    assert await ctx.db.count_formats(ADMIN_CFG) == 0  # nothing is added until they say so
+
+
+async def test_a_plain_start_still_opens_the_menu(ctx):
+    for text in ("/start", "/start hello", "/start fmt", "/start x_fmt_abc"):
+        ev = await say(ctx, ADMIN_CFG, text)
+        assert "m:formats" in data_of(ev.out[0][1]), text
+
+
+async def test_a_shared_format_with_a_thumbnail_comes_as_a_photo(ctx):
+    fmt, token = await share(ctx)
+    picture = jpeg((320, 180))
+    await ctx.db.set_format_thumb(OWNER, fmt["id"], picture)
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{token}")
+    assert ev.out == []
+    ((chat, file, kw),) = ctx.client.files
+    assert chat == ADMIN_CFG and file.getvalue() == picture and file.name.endswith(".jpg")
+    assert "📦 One Piece" in kw["caption"] and "✅ included" in kw["caption"] and kw["parse_mode"] == "html"
+    assert data_of(kw["buttons"]) == [f"fs:add:{token}", "x:close"]
+
+
+async def test_if_the_thumbnail_cannot_be_sent_the_details_still_come(ctx):
+    fmt, token = await share(ctx)
+    await ctx.db.set_format_thumb(OWNER, fmt["id"], jpeg())
+    ctx.client.fail_send_file = True
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{token}")
+    assert len(ev.out) == 1 and "📦 One Piece" in ev.texts[0] and f"fs:add:{token}" in data_of(ev.out[0][1])
+
+
+async def test_the_page_shows_the_format_as_it_is_now(ctx):
+    fmt, token = await share(ctx)
+    await ctx.db.update_format(OWNER, fmt["id"], template="Changed - {title}")
+    ev = await say(ctx, ADMIN_CFG, f"/start fmt_{token}")
+    assert "Changed - {title}" in ev.texts[0]
+
+
+async def test_the_owner_opening_their_own_link_gets_no_add_button(ctx):
+    fmt, token = await share(ctx)
+    ev = await say(ctx, OWNER, f"/start fmt_{token}")
+    assert "your own format" in ev.texts[0] and data_of(ev.out[0][1]) == [f"fm:v:{fmt['id']}", "x:close"]
+    cb = await click(ctx, OWNER, f"fs:add:{token}")  # a button from an old message
+    assert cb.alerts == ["That's your own format."] and await ctx.db.count_formats(OWNER) == 1
+
+
+async def test_strangers_cannot_open_a_shared_format(ctx):
+    fmt, token = await share(ctx)
+    ev = await say(ctx, STRANGER, f"/start fmt_{token}")
+    assert ev.out == []
+    assert len([m for m in ctx.client.sent if m[0] == LOG and "Ignored" in m[1]]) == 1  # the owner hears about it, once
+    cb = await click(ctx, STRANGER, f"fs:add:{token}")
+    assert cb.edits == [] and await ctx.db.count_formats(STRANGER) == 0
+
+
+async def test_links_that_lead_nowhere_say_so(ctx):
+    fmt, token = await share(ctx)
+    await ctx.db.delete_format(OWNER, fmt["id"])
+    for payload in (token, "unknown", "", "!!!", "x" * 40, "../../etc"):
+        ev = await say(ctx, ADMIN_CFG, f"/start fmt_{payload}")
+        assert ev.texts == [panels.SHARE_GONE], payload
+        assert data_of(ev.out[0][1]) == ["x:close"]
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    assert cb.alerts == ["That shared format isn't available anymore."] and cb.edits[-1][0] == panels.SHARE_GONE
+    for data in ("fs:add", "fs:add:", "fs:add:!!", "fs:nope:" + token, "fs"):
+        cb = await click(ctx, ADMIN_CFG, data)
+        assert await ctx.db.count_formats(ADMIN_CFG) == 0, data
+
+
+async def test_an_unknown_action_on_a_live_link_does_nothing(ctx):
+    _fmt, token = await share(ctx)
+    cb = await click(ctx, ADMIN_CFG, f"fs:nope:{token}")
+    assert cb.answers == [(None, False)] and cb.edits == [] and await ctx.db.count_formats(ADMIN_CFG) == 0
+
+
+# ---------------------------------------------------------------------------
+# Add to my formats
+# ---------------------------------------------------------------------------
+
+
+async def test_adding_a_shared_format_gives_the_user_their_own_copy(ctx):
+    fmt, token = await share(ctx, meta={"title": "One Piece"}, keep_audio=["japanese"], keep_subtitle=["english"])
+    await ctx.db.set_format_thumb(OWNER, fmt["id"], jpeg())
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    (mine,) = await ctx.db.list_formats(ADMIN_CFG)
+    assert mine["id"] != fmt["id"] and mine["name"] == "One Piece" and mine["template"] == "One Piece - E{episode}"
+    assert mine["meta"]["title"] == "One Piece" and mine["keep_audio"] == ["japanese"] and mine["keep_subtitle"] == ["english"]
+    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"]
+
+    # 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}")
+    assert (await ctx.db.get_format(OWNER, fmt["id"]))["template"] == "One Piece - E{episode}"
+    ev = await say(ctx, ADMIN_CFG, "/rename")
+    assert f"rn:p:{mine['id']}" in data_of(ev.out[0][1])
+    cb = await click(ctx, ADMIN_CFG, f"fm:v:{mine['id']}")  # "Open format"
+    assert "🗂 One Piece" in cb.edits[-1][0] and f"inline:share_{mine['id']}" in data_of(cb.edits[-1][1])
+    await ctx.db.delete_format(ADMIN_CFG, mine["id"])
+    assert await ctx.db.get_format(OWNER, fmt["id"]) is not None
+
+
+async def test_a_copy_is_renamed_when_the_name_is_taken_and_stops_at_the_limit(ctx):
+    _fmt, token = await share(ctx)
+    await make_format(ctx, "one piece", uid=ADMIN_CFG)
+    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)"]
+
+    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 await ctx.db.count_formats(ADMIN_CFG) == MAX_FORMATS
+
+
+async def test_a_format_deleted_by_its_owner_cannot_be_added_but_copies_stay(ctx):
+    fmt, token = await share(ctx)
+    await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    await ctx.db.delete_format(OWNER, fmt["id"])
+    assert await ctx.db.count_formats(ADMIN_CFG) == 1  # their copy is theirs
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    assert cb.alerts == ["That shared format isn't available anymore."] and await ctx.db.count_formats(ADMIN_CFG) == 1
+
+
+async def test_a_format_that_vanishes_while_it_is_being_added_is_reported(ctx, monkeypatch):
+    _fmt, token = await share(ctx)
+
+    async def gone(*_a, **_k):
+        return None
+
+    monkeypatch.setattr(ctx.db, "copy_format", gone)
+    cb = await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    assert cb.alerts == ["That shared format isn't available anymore."] and cb.edits[-1][0] == panels.SHARE_GONE
+
+
+async def test_the_shared_link_works_for_many_people_and_many_times(ctx):
+    _fmt, token = await share(ctx)
+    await click(ctx, ADMIN_CFG, f"fs:add:{token}")
+    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

tests/tgfakes.py

@@ -11,9 +11,12 @@ import re
 from types import SimpleNamespace
 from typing import Any, List, Optional, Tuple
 
-from telethon import events
+from telethon import TelegramClient, errors, events
 from telethon.extensions import html as telegram_html
 from telethon.helpers import add_surrogate, del_surrogate
+from telethon.sessions import StringSession
+from telethon.tl import types
+from telethon.tl.custom import InlineBuilder
 from telethon.tl.types import MessageEntityCode
 
 
@@ -25,6 +28,17 @@ def make_file(name: Optional[str] = "Movie.mkv", size: int = 5 * 1024 * 1024, mi
     return SimpleNamespace(name=name, size=size, mime_type=mime, ext=ext, width=width, height=height, duration=duration)
 
 
+def has_share_button(buttons: Any) -> bool:
+    """Is there a share (switch inline) button among Telethon buttons?"""
+    return any(isinstance(b.type, types.InlineButtonTypeSwitchInline) for row in buttons or [] for b in row)
+
+
+def refuse_share_button(client: Any, buttons: Any) -> None:
+    """Telegram refuses a message with a share button while inline mode is off for the bot (``client.server_inline``)."""
+    if client is not None and not client.server_inline and has_share_button(buttons):
+        raise errors.BotInlineDisabledError(None)
+
+
 class FakeMessage:
     def __init__(self, text: str = "", *, mid: int = 1, sender: int = 1, file: Any = None, video: bool = False,
                  audio: bool = False, photo: bool = False, sticker: bool = False, gif: bool = False,
@@ -73,6 +87,7 @@ class FakeEvent:
         self.photo_bytes = photo_bytes
 
     async def respond(self, text: Optional[str] = None, **kw: Any) -> SimpleNamespace:
+        refuse_share_button(getattr(self, "client", None), kw.get("buttons"))
         self.out.append((text, kw.get("buttons"), kw))
         return SimpleNamespace(id=1000 + len(self.out), text=text)
 
@@ -109,6 +124,7 @@ class FakeCallback:
         self.delete_error: Optional[Exception] = None
 
     async def edit(self, text: Optional[str] = None, **kw: Any) -> None:
+        refuse_share_button(getattr(self, "client", None), kw.get("buttons"))
         self.edits.append((text, kw.get("buttons")))
 
     async def answer(self, message: Optional[str] = None, *, alert: bool = False, **kw: Any) -> None:
@@ -131,6 +147,25 @@ class FakeCallback:
         return [m or "" for m, a in self.answers if m and not a]
 
 
+class FakeInlineQuery:
+    """An ``InlineQuery`` event.  Its builder is Telethon's own (it works offline), so the cards it makes are real."""
+
+    def __init__(self, sender: int, text: str = ""):
+        self.sender_id = sender
+        self.chat_id = sender
+        self.text = text
+        self.id = 77
+        self.builder = InlineBuilder(TelegramClient(StringSession(), 1, "0123456789abcdef0123456789abcdef"))
+        self.answers: List[tuple] = []  # (results, kwargs) of every answer()
+
+    async def answer(self, results: Any = None, **kw: Any) -> None:
+        self.answers.append((list(results or []), kw))
+
+    @property
+    def results(self) -> List[Any]:
+        return self.answers[-1][0] if self.answers else []
+
+
 class FakeClient:
     def __init__(self) -> None:
         self.handlers: List[tuple] = []
@@ -149,6 +184,14 @@ class FakeClient:
         self.media: dict = {}           # message id -> bytes that download_media() returns
         self.thumb_data: dict = {}      # message id -> bytes that download_media(thumb=...) returns
         self.downloads: List[tuple] = []
+        self.username = "RenameBot"
+        self.inline_placeholder: Optional[str] = "Pick a format"  # what the bot's profile says; None = inline mode is off
+        self.server_inline = True  # False: Telegram refuses messages that carry a share button
+        self.me_calls = 0
+
+    async def get_me(self) -> SimpleNamespace:
+        self.me_calls += 1
+        return SimpleNamespace(id=1, username=self.username, bot_inline_placeholder=self.inline_placeholder)
 
     def add_event_handler(self, callback: Any, event: Any = None) -> None:
         self.handlers.append((callback, event))
@@ -163,6 +206,7 @@ class FakeClient:
         return SimpleNamespace(id=entity)
 
     async def send_message(self, entity: Any, text: str = "", **kw: Any) -> SimpleNamespace:
+        refuse_share_button(self, kw.get("buttons"))
         self.sent.append((entity, text, kw))
         return SimpleNamespace(id=2000 + len(self.sent))
 
@@ -181,6 +225,7 @@ class FakeClient:
         self.deleted.append((entity, list(ids) if isinstance(ids, (list, tuple)) else [ids]))
 
     async def send_file(self, entity: Any, file: Any, **kw: Any) -> SimpleNamespace:
+        refuse_share_button(self, kw.get("buttons"))
         if self.fail_send_file:
             raise RuntimeError("cannot send file")
         errors_for = self.file_errors.get(getattr(file, "id", None))
@@ -192,14 +237,25 @@ class FakeClient:
     async def edit_message(self, entity: Any, message: Any = None, text: Optional[str] = None, **kw: Any) -> None:
         if text is None and isinstance(message, str):
             text, message = message, None
+        refuse_share_button(self, kw.get("buttons"))
         self.edited.append((entity, text, {**kw, "message": message}))
 
 
+def _family(obj: Any) -> str:
+    """Telethon builds each kind of event from the matching builder: callback queries, inline queries, new messages."""
+    if isinstance(obj, (events.CallbackQuery, FakeCallback)):
+        return "callback"
+    if isinstance(obj, (events.InlineQuery, FakeInlineQuery)):
+        return "inline"
+    return "message"
+
+
 async def dispatch(client: FakeClient, event: Any) -> None:
     """Run ``event`` through the registered handlers like Telethon's dispatcher."""
+    event.client = client
     for callback, builder in list(client.handlers):
-        if isinstance(builder, events.CallbackQuery) != isinstance(event, FakeCallback):
-            continue  # Telethon builds one event per builder type
+        if _family(builder) != _family(event):
+            continue
         builder.resolved = True
         passed = builder.filter(event)
         if inspect.isawaitable(passed):
@@ -212,11 +268,21 @@ async def dispatch(client: FakeClient, event: Any) -> None:
             break
 
 
+def button_data(button: Any) -> str:
+    """The callback data of a button; ``inline:<query>`` for a share button and ``url:<link>`` for a link."""
+    kind = button.type
+    if isinstance(kind, types.InlineButtonTypeSwitchInline):
+        return "inline:" + kind.query
+    if isinstance(kind, types.InlineButtonTypeUrl):
+        return "url:" + kind.url
+    return kind.data.decode()
+
+
 def button_rows(buttons: Any) -> List[List[tuple]]:
     """Telethon buttons -> ``[[(text, data_str), ...], ...]``."""
     out = []
     for row in buttons or []:
-        out.append([(b.text, b.type.data.decode()) for b in row])
+        out.append([(b.text, button_data(b)) for b in row])
     return out