release: 1.0.0

first stable release. pre-1.0.0 verification complete: all surviving MED regressions and
gaps resolved and independently re-fired, tree audited clean across the suite.

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

README.md

@@ -9,28 +9,31 @@ 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.4
+dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.8
 ```
 
 Direct:
 
 ```bash
-pip install "dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.4"
+pip install "dpy_paginator @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_paginator.git@v0.1.8"
 ```
 
 Requires `discord.py` (pulled transitively).
 
-Drop the `@v0.1.4` suffix from the line above to install the latest unpinned.
+Drop the `@v0.1.8` suffix from the line above to install the latest unpinned.
 
 ## Basic usage
 
+The paginator class is `DPYPaginator`. It is also exported as `ButtonPaginator` (a
+back-compat alias) — both names refer to the same class, so either import works.
+
 Plain pages — just navigation:
 
 ```python
-from dpy_paginator import ButtonPaginator
+from dpy_paginator import DPYPaginator      # or: from dpy_paginator import ButtonPaginator
 
 pages = [discord.Embed(title=f"Page {i}") for i in range(5)]
-await ButtonPaginator(pages, author_id=ctx.author.id).start(ctx)
+await DPYPaginator(pages, author_id=ctx.author.id).start(ctx)
 ```
 
 `start()` accepts an `Interaction` or any `Messageable` (a `Context`, channel, etc.).
@@ -41,7 +44,7 @@ Navigation uses plain Unicode by default — no setup, no emoji upload required.
 `emojis=` to override with custom application/guild emojis the bot can use:
 
 ```python
-ButtonPaginator(pages, emojis={
+DPYPaginator(pages, emojis={
     "previous": "<:icon_back:123...>",
     "next": "<:icon_next:123...>",
     "cache": "<:icon_cache:123...>",
@@ -54,7 +57,20 @@ 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.
+
+With `per_page > 1`, multiple entries render onto one page. `content` from each
+entry (whether a plain `str` entry or a dict's `content` key) joins with `\n` in
+order, same as `embeds`/`files`/`buttons` accumulate — no entry's content is
+dropped in favor of another's.
+
+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
 
@@ -83,7 +99,7 @@ for session in sessions:
         ],
     })
 
-paginator = ButtonPaginator(
+paginator = DPYPaginator(
     pages, cache=None, timeout=900, delete_message_after=True,
     mentions_allowed=discord.AllowedMentions.none(), ephemeral=True,
     page_text="Session {} of {}",
@@ -99,8 +115,6 @@ 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,13 +130,17 @@ for group in groups:
     pages.append(build_embed(group))
     cache.append(" ".join(f"<@{uid}>" for uid in group["user_ids"]))
 
-await ButtonPaginator(pages, cache=cache, cache_sleep=1.0).start(ctx)
+await DPYPaginator(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 — a shorter `cache` raises `ValueError` at
 construction rather than failing with an `IndexError` mid-navigation.
 
+The cache button renders whenever `cache` is truthy, even on a single page (no
+navigation row) — it doesn't depend on there being more than one page to flip
+through.
+
 ## Constructor options
 
 - `pages` — sequence of page content
@@ -135,6 +153,7 @@ construction rather than failing with an `IndexError` mid-navigation.
 - `ephemeral` — send/edit ephemerally
 - `page_text` — format string for the jump button label
 - `emojis` — override navigation emojis
+- `cache_sleep` — seconds to wait after cache-priming before refreshing (default 1.0)
 
 ## Subclassing
 

pyproject.toml

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

src/dpy_paginator/__init__.py

@@ -1,3 +1,10 @@
-from .dpy_paginator import ButtonPaginator, JumpToPageModal, DEFAULT_EMOJIS, Page
+from importlib.metadata import version, PackageNotFoundError
 
-__all__ = ["ButtonPaginator", "JumpToPageModal", "DEFAULT_EMOJIS", "Page"]
+from .dpy_paginator import DPYPaginator, ButtonPaginator, JumpToPageModal, DEFAULT_EMOJIS, Page
+
+try:
+    __version__ = version("dpy_paginator")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["DPYPaginator", "ButtonPaginator", "JumpToPageModal", "DEFAULT_EMOJIS", "Page", "__version__"]

src/dpy_paginator/dpy_paginator.py

@@ -3,27 +3,14 @@ button paginator for discord.py
 
 a discord.ui.View that paginates mixed content (strings, embeds, files,
 attachments, or dicts of mixed content with custom buttons) behind
-previous / jump / next navigation, with an optional cache button.
+previous / jump / next navigation, with an optional cache button. config-free;
+everything is passed at construction. see README for page-type and button-config
+details.
 
-    from dpy_paginator import ButtonPaginator
-
-    pages = [discord.Embed(title=f"Page {i}") for i in range(5)]
-    await ButtonPaginator(pages, author_id=ctx.author.id).start(ctx)
-
-emojis: navigation uses plain unicode by default (no setup). pass emojis= to
-override with custom application/guild emojis the bot can use:
-
-    ButtonPaginator(pages, emojis={
-        "previous": "<:icon_back:123...>",
-        "next": "<:icon_next:123...>",
-        "cache": "<:icon_cache:123...>",
-    })
-
-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).
-
-config-free: no host config import; everything is passed at construction.
+file pages get a fresh discord.File rebuilt from the same source on every render,
+since discord.py closes a File's handle after each send/edit. get_page_kwargs
+builds each page's kwargs/buttons in local state and only publishes once fully
+assembled, so concurrent interactions never interleave into a shared render.
 """
 
 from __future__ import annotations
@@ -97,7 +84,7 @@ class _CustomButton(discord.ui.Button):
 class JumpToPageModal(discord.ui.Modal, title="Jump to Page"):
     """modal that lets a user jump to a specific page"""
 
-    def __init__(self, paginator: "ButtonPaginator"):
+    def __init__(self, paginator: "DPYPaginator"):
         super().__init__()
         self.paginator = paginator
         self.page_number = discord.ui.TextInput(
@@ -125,7 +112,7 @@ class JumpToPageModal(discord.ui.Modal, title="Jump to Page"):
             )
 
 
-class ButtonPaginator(Generic[PageT_co], discord.ui.View):
+class DPYPaginator(Generic[PageT_co], discord.ui.View):
     """button-navigated paginator supporting mixed page content and custom buttons"""
 
     message: Optional[Union[discord.Message, discord.WebhookMessage]] = None
@@ -163,10 +150,8 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         """
         super().__init__(timeout=timeout)
         if not pages:
-            raise ValueError("ButtonPaginator requires at least one page")
+            raise ValueError("DPYPaginator 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
@@ -183,14 +168,11 @@ 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)
-        # 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"
             )
-        self._page_kwargs: Dict[str, Any] = self._fresh_kwargs()
 
     def _fresh_kwargs(self) -> Dict[str, Any]:
         """a clean page-kwargs dict"""
@@ -233,19 +215,40 @@ 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
+
+        concurrency-safe: publishes self.current_page_buttons only once the page
+        is fully assembled, so an interleaved concurrent call never observes a
+        partially-built page.
+        """
+        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: builds kwargs/buttons in locals, never touching instance
+        attributes mid-build, so concurrent calls hold their own state until
+        get_page_kwargs publishes the 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),
@@ -259,52 +262,55 @@ 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
+                    # wrong-typed value would collide with base embeds=[]/files=[]; reject early
                     raise ValueError(
                         f"page key {key!r} has unexpected type {type(value).__name__}"
                     )
+                elif key == "content":
+                    if value is None:
+                        continue
+                    existing = kwargs["content"]
+                    kwargs["content"] = value if existing is None else f"{existing}\n{value}"
                 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, 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.
+        nav=False (or a single page, max_pages < 2) drops prev/jump/next but keeps
+        custom and cache buttons; the cache button renders independent of nav
+        whenever self.cache is truthy.
         """
         self.clear_items()
 
@@ -321,11 +327,11 @@ 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)
+        if self.cache:
+            self.cache_button.emoji = self.emojis["cache"]
+            self.add_item(self.cache_button)
 
+        if nav:
             self.next_page.emoji = self.emojis["next"]
             self.next_page.disabled = self.current_page >= self.max_pages - 1
             self.add_item(self.next_page)
@@ -360,13 +366,11 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
     async def cache_button(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
         """prime the viewer's client mention cache, then refresh the current view
 
-        discord clients render <@id> as a raw id until the user object is cached.
-        this posts the page's mentions in a throwaway ephemeral message so the client
-        resolves them, waits cache_sleep seconds, then re-edits the message so the
-        mentions display as names — no manual page-flip needed.
-
-        allowed_mentions is none() on purpose: the <@id> tags still render (which is
-        what primes the cache) but no actual ping/notification fires.
+        a mention-cache primer, not a data cache: posts the page's mentions in a
+        throwaway ephemeral message (allowed_mentions=none(), tags render but no
+        ping fires) to force client resolution, waits cache_sleep seconds, then
+        re-edits so mentions display as names. expected discord failures (deleted
+        message, no permission) are swallowed, like on_timeout.
         """
         await interaction.response.send_message(
             content=self.cache[self.current_page],
@@ -377,7 +381,12 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         await asyncio.sleep(self.cache_sleep)
         kwargs = await self._build_render_kwargs()
         if self.message:
-            await self.message.edit(**kwargs)
+            try:
+                await self.message.edit(**kwargs)
+            except (discord.NotFound, discord.Forbidden):
+                pass
+            except discord.HTTPException:
+                log.warning("paginator cache_button: failed to refresh message", exc_info=True)
 
     @discord.ui.button(style=discord.ButtonStyle.blurple)
     async def next_page(self, interaction: Interaction, _: discord.ui.Button[Self]) -> None:
@@ -386,36 +395,57 @@ 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 fp after every send/edit; file.reset() raises
+        once a path-backed File is actually closed, so rebuild from source instead.
+        """
+        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 (_owner=True) reopens from fp.name; a buffer-backed File (_owner=False)
+        is never closed by discord.py, so its buffer is rewound and reused"""
+        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
+        # single page: update_buttons drops nav but keeps custom/cache buttons live;
+        # only drop the view entirely below if neither is present
         self.update_buttons()
 
-        if self.max_pages < 2 and not self.current_page_buttons:
-            # single page, no custom buttons: no interactive row at all, drop the view
+        if self.max_pages < 2 and not self.current_page_buttons and not self.cache:
             self.stop()
             kwargs.pop("view", None)
 
         self.reset_files(kwargs)
 
         if isinstance(obj, discord.Interaction):
-            # ephemeral is an interaction-response concept; only these paths accept it
+            # ephemeral only applies to interaction-response paths
             if obj.response.is_done():
                 self.message = await obj.followup.send(**kwargs, ephemeral=self.ephemeral, **send_kwargs)
             else:
                 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
+            # a raw channel's send 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__}")
@@ -425,8 +455,8 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
     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.
+        only expected discord failures (already deleted, no permission) are
+        swallowed; unexpected errors surface.
         """
         if not self.delete_message_after or self.message is None:
             return
@@ -435,6 +465,10 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         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
+            # best-effort cleanup task; log rather than raise into an unretrieved task
             log.warning("paginator on_timeout: failed to delete message", exc_info=True)
+
+
+# back-compat alias: the class was originally named ButtonPaginator; DPYPaginator is
+# the canonical name (matching the package), both refer to the same class
+ButtonPaginator = DPYPaginator