fix: rebuild fresh File per render, convert Attachments in files= list, thread page state through locals

discord.py closes a discord.File's fp after every send/edit, so reusing the
same File object across renders raised ValueError on navigating back to a
file page; reset_files now rebuilds a fresh File from the same source
instead. The dict page 'files' list never converted discord.Attachment to
File (unlike the singular 'file' key), crashing reset_files with
AttributeError; it now converts via to_file() like its sibling. get_page_kwargs
also built render state in instance attributes across real await points,
letting two near-simultaneous interactions interleave into a merged render;
it now builds in locals and threads them through the recursive branch,
publishing self.current_page_buttons only once a page is fully assembled.

Bump to v0.1.5.

Signed-off-by: disqualifier <dev@disqualifier.me>

.gitignore

@@ -1,5 +1,5 @@
 # claude
-CLAUDE.md
+.claude/
 
 # python
 __pycache__/

README.md

@@ -9,17 +9,19 @@ buttons) behind previous / jump / next navigation, with an optional cache button
 `requirements.txt`:
 
 ```
-dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.0
+dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.5
 ```
 
 Direct:
 
 ```bash
-pip install "dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.0"
+pip install "dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.5"
 ```
 
 Requires `discord.py` (pulled transitively).
 
+Drop the `@v0.1.5` suffix from the line above to install the latest unpinned.
+
 ## Basic usage
 
 Plain pages — just navigation:
@@ -52,7 +54,15 @@ Unset keys fall back to the Unicode defaults.
 
 A page may be a `str`, `discord.Embed`, `discord.File`/`Attachment`, a sequence of
 those, or a `dict`. A dict page can carry `content`, `embed`/`embeds`,
-`file`/`files`, and a `buttons` list of custom button configs.
+`file`/`files`, and a `buttons` list of custom button configs. Both `file` and
+`files` accept a `discord.Attachment` and convert it via `to_file()` automatically —
+you never need to convert an attachment before passing it in.
+
+File pages are safe to navigate back to. discord.py closes a `discord.File`'s
+underlying handle after every send/edit, so the paginator never resends your File
+object directly — it rebuilds a fresh `discord.File` from the same source (path or
+buffer) on every render, so `pages` can hold a `discord.File` once and be paged
+back and forth indefinitely.
 
 ## Custom per-page buttons
 
@@ -97,6 +107,8 @@ echoes its `data`.
 ## Cache button (mention priming)
 
 Discord clients render `<@id>` as a raw id until the user object is cached locally.
+Omit `cache` (or pass `None` / `[]`) and the button never appears; a non-empty cache
+must have one entry per page or construction raises.
 The cache button fixes that: pass `cache=[...]` with one entry per page, where each
 entry is a string of the user mentions on that page (`"<@111> <@222> <@333>"`).
 
@@ -116,7 +128,8 @@ await ButtonPaginator(pages, cache=cache, cache_sleep=1.0).start(ctx)
 ```
 
 Omit `cache` or pass `None`/`[]` and the button never appears. When set, `cache`
-must have one entry per rendered page.
+must have one entry per rendered page — a shorter `cache` raises `ValueError` at
+construction rather than failing with an `IndexError` mid-navigation.
 
 ## Constructor options
 
@@ -138,4 +151,4 @@ in an embed). It may be sync or async.
 
 ## Versioning
 
-Tagged `vX.Y.Z`. Pin the tag in `requirements.txt`.
+Releases are tagged `vX.Y.Z`. The install line above pins a release; drop the `@vX.Y.Z` suffix to install the latest unpinned. Pin deliberately for reproducible installs.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dpy_paginator"
-version = "0.1.0"
+version = "0.1.5"
 description = "Button-navigated paginator for discord.py — config-free, injectable emojis, installable."
 requires-python = ">=3.10"
 dependencies = [

src/dpy_paginator/dpy_paginator.py

@@ -21,7 +21,21 @@ override with custom application/guild emojis the bot can use:
 
 page types: a page may be a str, a discord.Embed, a discord.File/Attachment,
 a sequence of those, or a dict. a dict page can carry 'content'/'embed(s)'/
-'file(s)' plus a 'buttons' list of custom button configs (see README).
+'file(s)' plus a 'buttons' list of custom button configs (see README). both
+the singular 'file' and plural 'files' dict keys accept a discord.Attachment
+and convert it via to_file() — neither key requires the caller to convert
+first.
+
+file pages are re-rendered safely: discord.py closes a discord.File's
+underlying handle after every send/edit, so the paginator never resends a
+consumer-supplied File object directly — it rebuilds a fresh discord.File
+from the same source (path or buffer) on every render, including the first.
+
+concurrency: get_page_kwargs builds each page's kwargs/buttons in local
+state and only publishes them once the whole page (including any awaited
+format_page or Attachment.to_file() conversions) is fully assembled, so two
+near-simultaneous interactions (e.g. rapid button clicks) never interleave
+into a merged or shared render.
 
 config-free: no host config import; everything is passed at construction.
 """
@@ -29,6 +43,7 @@ config-free: no host config import; everything is passed at construction.
 from __future__ import annotations
 
 import asyncio
+import logging
 from typing import (
     Any,
     Dict,
@@ -69,6 +84,8 @@ DEFAULT_EMOJIS = {
     "cache": "\U0001f5c2\ufe0f",  # 🗂️
 }
 
+log = logging.getLogger(__name__)
+
 PageT_co = TypeVar("PageT_co", bound=Page, covariant=True)
 
 
@@ -159,6 +176,12 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
             cache_sleep: seconds to wait after priming before refreshing the view
         """
         super().__init__(timeout=timeout)
+        if not pages:
+            raise ValueError("ButtonPaginator requires at least one page")
+        if per_page < 1:
+            # per_page <= 0 would ZeroDivisionError (==0) or yield a negative max_pages
+            # (<0) at the divmod below; fail loud like the other construction guards
+            raise ValueError("per_page must be >= 1")
         self.author_id: Optional[int] = author_id
         self.delete_message_after: bool = delete_message_after
         self.mentions_allowed = mentions_allowed or discord.AllowedMentions.all()
@@ -174,7 +197,13 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
 
         total_pages, left_over = divmod(len(self.pages), self.per_page)
         self.max_pages: int = total_pages + (1 if left_over else 0)
-        self._page_kwargs: Dict[str, Any] = self._fresh_kwargs()
+        # a falsy cache (None or []) disables the cache button (see the render path's
+        # `if self.cache:`); only a non-empty cache must have one entry per page
+        if cache and len(cache) < self.max_pages:
+            raise ValueError(
+                f"cache has {len(cache)} entries but there are {self.max_pages} pages; "
+                "cache needs one entry per page"
+            )
 
     def _fresh_kwargs(self) -> Dict[str, Any]:
         """a clean page-kwargs dict"""
@@ -193,7 +222,7 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
 
     async def interaction_check(self, interaction: Interaction) -> bool:
         """restrict interaction to author_id when set"""
-        if not self.author_id or self.author_id == interaction.user.id:
+        if self.author_id is None or self.author_id == interaction.user.id:
             return True
         await interaction.response.send_message("You cannot interact with this menu.", ephemeral=True)
         return False
@@ -202,7 +231,7 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         """return the content for a page index, wrapping out-of-range to 0"""
         if page_number < 0 or page_number >= self.max_pages:
             self.current_page = 0
-            return self.pages[self.current_page]
+            return self.get_page(0)
         if self.per_page == 1:
             return self.pages[page_number]
         base = page_number * self.per_page
@@ -217,19 +246,44 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
     async def get_page_kwargs(
         self, page: Union[PageT_co, Sequence[PageT_co]], skip_formatting: bool = False
     ) -> Dict[str, Any]:
-        """build the send/edit kwargs for a page, extracting any custom buttons"""
+        """build the send/edit kwargs for a page, extracting any custom buttons
+
+        builds into local state and publishes self.current_page_buttons only once
+        the whole page (including any nested recursion and awaited conversions) is
+        fully assembled, so an interleaved concurrent call never observes or
+        mutates a partially-built page (see _get_page_kwargs).
+        """
+        kwargs, buttons = await self._get_page_kwargs(page, skip_formatting=skip_formatting)
+        self.current_page_buttons = buttons
+        return kwargs
+
+    async def _get_page_kwargs(
+        self,
+        page: Union[PageT_co, Sequence[PageT_co]],
+        skip_formatting: bool = False,
+        kwargs: Optional[Dict[str, Any]] = None,
+        buttons: Optional[List[discord.ui.Button]] = None,
+    ) -> Tuple[Dict[str, Any], List[discord.ui.Button]]:
+        """recursive worker: build kwargs/buttons in locals, threaded through recursion
+
+        instance attributes are never read or written mid-build, so concurrent
+        interactions each hold their own kwargs/buttons until get_page_kwargs
+        publishes the finished result.
+        """
+        if kwargs is None:
+            kwargs = self._fresh_kwargs()
+        if buttons is None:
+            buttons = []
+
         if not skip_formatting:
-            self._page_kwargs = self._fresh_kwargs()
             formatted_page = await discord.utils.maybe_coroutine(self.format_page, page)
         else:
             formatted_page = page
 
-        self.current_page_buttons = []
-
         if isinstance(formatted_page, dict):
             formatted_page = dict(formatted_page)
             for config in formatted_page.pop("buttons", []):
-                self.current_page_buttons.append(
+                buttons.append(
                     _CustomButton(
                         label=config.get("label", "Button"),
                         style=config.get("style", discord.ButtonStyle.gray),
@@ -243,40 +297,61 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
 
             for key, value in formatted_page.items():
                 if key == "embeds" and isinstance(value, list):
-                    self._page_kwargs["embeds"].extend(value)
+                    kwargs["embeds"].extend(value)
                 elif key == "embed" and isinstance(value, discord.Embed):
-                    self._page_kwargs["embeds"].append(value)
+                    kwargs["embeds"].append(value)
                 elif key == "files" and isinstance(value, list):
-                    self._page_kwargs["files"].extend(value)
+                    for item in value:
+                        if isinstance(item, discord.Attachment):
+                            item = await item.to_file()
+                        kwargs["files"].append(item)
                 elif key == "file" and isinstance(value, (discord.File, discord.Attachment)):
                     if isinstance(value, discord.Attachment):
                         value = await value.to_file()
-                    self._page_kwargs["files"].append(value)
+                    kwargs["files"].append(value)
+                elif key in ("embed", "embeds", "file", "files"):
+                    # a wrong-typed embed/file would otherwise fall to the catch-all and
+                    # be forwarded verbatim, colliding with the base embeds=[]/files=[]
+                    # and raising an opaque TypeError from inside discord.py — reject it
+                    # here with a clear, paginator-side message
+                    raise ValueError(
+                        f"page key {key!r} has unexpected type {type(value).__name__}"
+                    )
                 else:
-                    self._page_kwargs[key] = value
+                    kwargs[key] = value
         elif isinstance(formatted_page, str):
-            content = self._page_kwargs["content"]
-            self._page_kwargs["content"] = (
+            content = kwargs["content"]
+            kwargs["content"] = (
                 formatted_page if content is None else f"{content}\n{formatted_page}"
             )
         elif isinstance(formatted_page, discord.Embed):
-            self._page_kwargs["embeds"].append(formatted_page)
+            kwargs["embeds"].append(formatted_page)
         elif isinstance(formatted_page, (discord.File, discord.Attachment)):
             if isinstance(formatted_page, discord.Attachment):
                 formatted_page = await formatted_page.to_file()
-            self._page_kwargs["files"].append(formatted_page)
+            kwargs["files"].append(formatted_page)
         elif isinstance(formatted_page, (tuple, list)):
             for item in formatted_page:
-                await self.get_page_kwargs(item, skip_formatting=True)
+                await self._get_page_kwargs(item, skip_formatting=True, kwargs=kwargs, buttons=buttons)
         else:
             raise TypeError("page content must be str, discord.Embed, file/attachment, sequence, or dict")
 
-        return self._page_kwargs
+        return kwargs, buttons
 
-    def update_buttons(self) -> None:
-        """rebuild the action row for the current page state"""
+    def update_buttons(self, nav: bool = True) -> None:
+        """rebuild the action row for the current page state
+
+        nav=False rebuilds with only the page's custom buttons and no navigation
+        items (prev/jump/cache/next) — a single-page result that still carries
+        custom buttons keeps them (and their live callbacks) without a nav row.
+        the nav row is also suppressed for a single page (max_pages < 2) even when
+        nav is left at its default, so a re-render (update_page) never resurrects it.
+        """
         self.clear_items()
 
+        nav = nav and self.max_pages >= 2
+
+        if nav:
             self.previous_page.emoji = self.emojis["previous"]
             self.previous_page.disabled = self.current_page <= 0
             self.add_item(self.previous_page)
@@ -287,6 +362,7 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         for button in self.current_page_buttons:
             self.add_item(button)
 
+        if nav:
             if self.cache:
                 self.cache_button.emoji = self.emojis["cache"]
                 self.add_item(self.cache_button)
@@ -351,33 +427,89 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         await self.update_page(interaction)
 
     def reset_files(self, page_kwargs: Dict[str, Any]) -> None:
-        """rewind file pointers so they can be sent again"""
-        for file in page_kwargs.get("files", []):
-            file.reset()
+        """swap in a fresh discord.File per render so a re-render never reuses a sent one
+
+        discord.py closes a File's underlying fp after every send/edit
+        (MultipartParameters.__exit__ -> file.close()), so the SAME File object is
+        single-use. Rather than call file.reset() (which raises 'seek of closed
+        file' the moment a path-backed File has actually been closed), rebuild a
+        new discord.File from the same source for every entry — cheap, and safe
+        whether or not the previous render already consumed it.
+        """
+        files = page_kwargs.get("files")
+        if not files:
+            return
+        page_kwargs["files"] = [self._fresh_file(file) for file in files]
+
+    @staticmethod
+    def _fresh_file(file: discord.File) -> discord.File:
+        """build a new discord.File from an existing one's source
+
+        a path-backed File (fp opened internally, _owner=True) is reopened from
+        fp.name, the path it was constructed with — fp.name stays readable even
+        after discord.py has closed the handle, so this works whether or not the
+        previous render already consumed it. a buffer-backed File (caller passed
+        an io object, _owner=False) is never closed by discord.py (see
+        File.close(), which only closes _owner=True files) so its buffer is
+        rewound to its starting position and reused directly.
+        """
+        if file._owner:
+            source = file.fp.name
+        else:
+            source = file.fp
+            source.seek(file._original_pos)
+        return discord.File(
+            source,
+            filename=file.filename,
+            spoiler=file.spoiler,
+            description=file.description,
+        )
 
     async def start(
         self, obj: Union[Interaction, Messageable], **send_kwargs: Any
     ) -> Optional[Union[discord.Message, discord.WebhookMessage]]:
         """send the first page; obj is an Interaction or a Messageable"""
         kwargs = await self.get_page_kwargs(self.get_page(self.current_page))
+        # update_buttons already suppresses the nav row for a single page (max_pages < 2),
+        # keeping only the page's custom buttons — so a single page with custom buttons
+        # renders them (live callbacks) with no nav row
         self.update_buttons()
 
-        if self.max_pages < 2:
+        if self.max_pages < 2 and not self.current_page_buttons:
+            # single page, no custom buttons: no interactive row at all, drop the view
             self.stop()
             kwargs.pop("view", None)
 
         self.reset_files(kwargs)
-        send_kwargs["ephemeral"] = self.ephemeral
 
         if isinstance(obj, discord.Interaction):
+            # ephemeral is an interaction-response concept; only these paths accept it
             if obj.response.is_done():
-                self.message = await obj.followup.send(**kwargs, **send_kwargs)
+                self.message = await obj.followup.send(**kwargs, ephemeral=self.ephemeral, **send_kwargs)
             else:
-                await obj.response.send_message(**kwargs, **send_kwargs)
+                await obj.response.send_message(**kwargs, ephemeral=self.ephemeral, **send_kwargs)
                 self.message = await obj.original_response()
         elif isinstance(obj, Messageable):
+            # Messageable.send (a raw channel) has no ephemeral param — never pass it
             self.message = await obj.send(**kwargs, **send_kwargs)
         else:
             raise TypeError(f"expected Interaction or Messageable, got {obj.__class__.__name__}")
 
         return self.message
+
+    async def on_timeout(self) -> None:
+        """delete the message on timeout when delete_message_after is set
+
+        only the expected discord failures (already deleted, or no permission) are
+        swallowed; an unexpected error surfaces rather than being silently dropped.
+        """
+        if not self.delete_message_after or self.message is None:
+            return
+        try:
+            await self.message.delete()
+        except (discord.NotFound, discord.Forbidden):
+            pass
+        except discord.HTTPException:
+            # on_timeout runs as a fire-and-forget task; a transient delete failure must
+            # not surface as an unretrieved-task traceback on a best-effort cleanup
+            log.warning("paginator on_timeout: failed to delete message", exc_info=True)