fix: single page keeps custom buttons instead of dropping the view (v0.1.2)

a single-page result (max_pages < 2) suppressed the navigation row by dropping the
whole view, which also discarded the consumer's custom per-page buttons. now: if the
page carries custom buttons, keep the view and rebuild with update_buttons(nav=False)
— nav items suppressed, custom buttons kept, and stop() NOT called so their callbacks
still fire. a page with no custom buttons keeps the original drop-the-view behavior.

verified by execution against real discord.py: single page + custom button -> start()
-> callback FIRES on click (view kept, stop() not called); negative control on the old
code drops the button entirely; the no-button single-page case is unregressed.

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

README.md

@@ -9,13 +9,13 @@ 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.2
 ```
 
 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.2"
 ```
 
 Requires `discord.py` (pulled transitively).
@@ -116,7 +116,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
 

pyproject.toml

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

src/dpy_paginator/dpy_paginator.py

@@ -159,6 +159,8 @@ 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")
         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,6 +176,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)
+        if cache is not None 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]:
@@ -202,7 +209,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
@@ -273,10 +280,16 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
 
         return self._page_kwargs
 
-    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.
+        """
         self.clear_items()
 
+        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 +300,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)
@@ -363,21 +377,41 @@ class ButtonPaginator(Generic[PageT_co], discord.ui.View):
         self.update_buttons()
 
         if self.max_pages < 2:
+            if self.current_page_buttons:
+                # single page WITH custom buttons: keep the view live so the
+                # buttons' callbacks still fire; strip only the navigation row
+                self.update_buttons(nav=False)
+            else:
+                # single page, no custom buttons: no interactive row at all
                 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