aline-ai 0.6.2__py3-none-any.whl → 0.6.3__py3-none-any.whl

realign/dashboard/widgets/events_table.py

@@ -80,23 +80,16 @@ class EventsTable(Container):
     }
 
     EventsTable .table-container {
-        height: auto;
+        height: 1fr;
         overflow-x: auto;
-        overflow-y: hidden;
+        overflow-y: auto;
     }
 
     EventsTable DataTable {
         height: auto;
         max-height: 100%;
         overflow-x: auto;
-        overflow-y: hidden;
-    }
-
-    EventsTable .pagination-info {
-        height: 1;
-        margin-top: 1;
-        color: $text-muted;
-        text-align: center;
+        overflow-y: auto;
     }
 
     EventsTable .stats-info {
@@ -107,9 +100,9 @@ class EventsTable(Container):
     """
 
     # Reactive properties
-    current_page: reactive[int] = reactive(1)
-    rows_per_page: reactive[int] = reactive(10)
     wrap_mode: reactive[bool] = reactive(False)
+    # Maximum events to load (for scrollable list)
+    MAX_EVENTS: int = 500
 
     def __init__(self) -> None:
         super().__init__()
@@ -122,8 +115,9 @@ class EventsTable(Container):
         self._refresh_worker: Optional[Worker] = None
         self._share_export_worker: Optional[Worker] = None
         self._refresh_timer = None
-        self._active_refresh_snapshot: Optional[tuple[int, int]] = None
-        self._pending_refresh_snapshot: Optional[tuple[int, int]] = None
+        self._is_refreshing: bool = False
+        self._pending_refresh: bool = False
+        self._saved_cursor_event_id: Optional[str] = None
 
     def compose(self) -> ComposeResult:
         """Compose the events table layout."""
@@ -150,7 +144,6 @@ class EventsTable(Container):
             yield Static(id="section-header", classes="section-header")
             with Container(classes="table-container"):
                 yield EventsListTable(id="events-table")
-            yield Static(id="pagination-info", classes="pagination-info")
             yield Static(id="stats-info", classes="stats-info")
             logger.debug("EventsTable.compose() completed")
         except Exception as e:
@@ -164,22 +157,19 @@ class EventsTable(Container):
             table = self.query_one("#events-table", EventsListTable)
             table.owner = self
             self._setup_table_columns(table)
-
-            # Calculate initial rows per page
-            self._calculate_rows_per_page()
             logger.debug("EventsTable.on_mount() completed")
         except Exception as e:
             logger.error(f"EventsTable.on_mount() failed: {e}\n{traceback.format_exc()}")
             raise
 
     def on_resize(self) -> None:
-        """Handle window resize to adjust rows per page."""
-        self._sync_to_available_height()
+        """Handle window resize."""
+        pass  # No longer need to recalculate pagination
 
     def on_show(self) -> None:
-        """Re-sync pagination when the tab becomes visible."""
+        """Refresh data when the tab becomes visible."""
         if self._refresh_timer is None:
-            self._refresh_timer = self.set_interval(5.0, self._on_refresh_timer)
+            self._refresh_timer = self.set_interval(60.0, self._on_refresh_timer)
         else:
             try:
                 self._refresh_timer.resume()
@@ -197,9 +187,7 @@ class EventsTable(Container):
             pass
 
     def _on_became_visible(self) -> None:
-        self._sync_to_available_height()
         self._load_events()
-        self._update_display()
         try:
             self.query_one("#events-table", DataTable).focus()
         except Exception:
@@ -388,41 +376,6 @@ class EventsTable(Container):
         share_btn = self.query_one("#share-event-btn", Button)
         share_btn.disabled = selected_count == 0
 
-    def _sync_to_available_height(self) -> None:
-        """Recalculate rows per page and reload if the page size changed."""
-        old_rows_per_page = self.rows_per_page
-        self._calculate_rows_per_page()
-
-        if self.rows_per_page != old_rows_per_page:
-            total_pages = self._get_total_pages()
-            if self.current_page > total_pages:
-                self.current_page = total_pages
-            self._load_events()
-
-        self._update_display()
-
-    def _calculate_rows_per_page(self) -> None:
-        """Calculate rows per page based on available height."""
-        try:
-            panel_height = self.size.height
-
-            # Calculate exact space needed:
-            # - Summary section: ~1 line content + 2 border + 2 padding + 1 margin = 6
-            # - Section header: 1 line + 1 margin = 2
-            # - Table header row: 1
-            # - Pagination info: 1 line + 1 margin = 2
-            # - Panel padding: 2 (top + bottom)
-            # - Extra buffer: 3
-
-            fixed_height = 6 + 2 + 1 + 2 + 2 + 3  # = 16
-
-            available_for_rows = panel_height - fixed_height
-            rows = max(available_for_rows, 3)  # At least 3 rows
-
-            self.rows_per_page = rows
-        except Exception:
-            self.rows_per_page = 10
-
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         button_id = event.button.id or ""
         if button_id == "share-import-btn":
@@ -442,25 +395,6 @@ class EventsTable(Container):
 
         self.app.push_screen(ShareImportScreen())
 
-    def _get_total_pages(self) -> int:
-        """Calculate total pages."""
-        if self._total_events == 0:
-            return 1
-        return (self._total_events + self.rows_per_page - 1) // self.rows_per_page
-
-    def action_next_page(self) -> None:
-        """Go to next page."""
-        total_pages = self._get_total_pages()
-        if self.current_page < total_pages:
-            self.current_page += 1
-            self._load_events()
-
-    def action_prev_page(self) -> None:
-        """Go to previous page."""
-        if self.current_page > 1:
-            self.current_page -= 1
-            self._load_events()
-
     def _on_refresh_timer(self) -> None:
         self.refresh_data(force=False)
 
@@ -469,26 +403,37 @@ class EventsTable(Container):
         if not self.display:
             return
 
-        snapshot = (int(self.current_page), int(self.rows_per_page))
         if self._refresh_worker is not None and self._refresh_worker.state in (
             WorkerState.PENDING,
             WorkerState.RUNNING,
         ):
             if force:
-                self._pending_refresh_snapshot = snapshot
+                self._pending_refresh = True
             return
 
-        if force and self._pending_refresh_snapshot is not None:
-            snapshot = self._pending_refresh_snapshot
-            self._pending_refresh_snapshot = None
+        # Save current cursor position before refresh
+        self._save_cursor_position()
 
         def work() -> dict:
-            return self._collect_snapshot(*snapshot)
+            return self._collect_all_events()
 
-        self._active_refresh_snapshot = snapshot
-        self._pending_refresh_snapshot = None
+        self._is_refreshing = True
+        self._pending_refresh = False
         self._refresh_worker = self.run_worker(work, thread=True, exit_on_error=False)
 
+    def _save_cursor_position(self) -> None:
+        """Save the current cursor event ID to restore after refresh."""
+        try:
+            table = self.query_one("#events-table", DataTable)
+            if table.row_count > 0:
+                self._saved_cursor_event_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
+            else:
+                self._saved_cursor_event_id = None
+        except Exception:
+            self._saved_cursor_event_id = None
+
     def _load_events(self) -> None:
         """Compatibility hook (tests stub this); default triggers async refresh."""
         if not self.is_mounted:
@@ -510,30 +455,29 @@ class EventsTable(Container):
 
         if event.state == WorkerState.ERROR:
             result = {
-                "snapshot": self._active_refresh_snapshot,
                 "total_events": 0,
                 "events": [],
             }
+            self._is_refreshing = False
         elif event.state != WorkerState.SUCCESS:
             return
         else:
             result = self._refresh_worker.result or {}
+            self._is_refreshing = False
 
-        snapshot = result.get("snapshot")
-        if snapshot == (int(self.current_page), int(self.rows_per_page)):
-            try:
-                self._total_events = int(result.get("total_events") or 0)
-            except Exception:
-                self._total_events = 0
-            try:
-                self._events = list(result.get("events") or [])
-                self._events_by_id = {e["id"]: e for e in self._events}
-            except Exception:
-                self._events = []
-                self._events_by_id = {}
-            self._update_display()
+        try:
+            self._total_events = int(result.get("total_events") or 0)
+        except Exception:
+            self._total_events = 0
+        try:
+            self._events = list(result.get("events") or [])
+            self._events_by_id = {e["id"]: e for e in self._events}
+        except Exception:
+            self._events = []
+            self._events_by_id = {}
+        self._update_display()
 
-        if self._pending_refresh_snapshot is not None:
+        if self._pending_refresh:
             self.refresh_data()
 
     def _start_share_export(self) -> None:
@@ -718,8 +662,8 @@ class EventsTable(Container):
             return ""
         return ""
 
-    def _collect_snapshot(self, page: int, rows_per_page: int) -> dict:
-        """Collect events for a single page (background thread)."""
+    def _collect_all_events(self) -> dict:
+        """Collect all events (background thread)."""
         total_events: int = 0
         events: list[dict] = []
 
@@ -733,8 +677,7 @@ class EventsTable(Container):
             row = conn.execute("SELECT COUNT(*) FROM events").fetchone()
             total_events = int(row[0]) if row else 0
 
-            # Get paginated events with session count
-            offset = (int(page) - 1) * int(rows_per_page)
+            # Get all events (up to MAX_EVENTS)
             try:
                 rows = conn.execute(
                     """
@@ -749,9 +692,9 @@ class EventsTable(Container):
                         (SELECT COUNT(*) FROM event_sessions WHERE event_id = e.id) AS session_count
                     FROM events e
                     ORDER BY e.created_at DESC
-                    LIMIT ? OFFSET ?
+                    LIMIT ?
                     """,
-                    (int(rows_per_page), int(offset)),
+                    (self.MAX_EVENTS,),
                 ).fetchall()
                 has_new_columns = True
             except Exception:
@@ -766,9 +709,9 @@ class EventsTable(Container):
                         (SELECT COUNT(*) FROM event_sessions WHERE event_id = e.id) AS session_count
                     FROM events e
                     ORDER BY e.created_at DESC
-                    LIMIT ? OFFSET ?
+                    LIMIT ?
                     """,
-                    (int(rows_per_page), int(offset)),
+                    (self.MAX_EVENTS,),
                 ).fetchall()
                 has_new_columns = False
 
@@ -826,7 +769,7 @@ class EventsTable(Container):
 
                 events.append(
                     {
-                        "index": offset + i + 1,
+                        "index": i + 1,
                         "id": event_id,
                         "short_id": self._shorten_id(event_id),
                         "title": title,
@@ -844,7 +787,6 @@ class EventsTable(Container):
             events = []
 
         return {
-            "snapshot": (int(page), int(rows_per_page)),
             "total_events": total_events,
             "events": events,
         }
@@ -860,18 +802,23 @@ class EventsTable(Container):
 
         # Update table
         table = self.query_one("#events-table", DataTable)
-        selected_event_id = None
-        try:
-            if table.row_count > 0:
-                selected_event_id = str(
-                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
-                )
-        except Exception:
-            selected_event_id = None
+
+        # Use saved cursor position if available, otherwise try to get current
+        restore_event_id = self._saved_cursor_event_id
+        if restore_event_id is None:
+            try:
+                if table.row_count > 0:
+                    restore_event_id = str(
+                        table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                    )
+            except Exception:
+                restore_event_id = None
+
         table.clear()
 
-        # Always enable horizontal scrollbar
+        # Always enable scrollbars
         table.styles.overflow_x = "auto"
+        table.styles.overflow_y = "auto"
         table.show_horizontal_scrollbar = True
 
         for event in self._events:
@@ -902,10 +849,10 @@ class EventsTable(Container):
             )
 
         if table.row_count > 0:
-            if selected_event_id:
+            if restore_event_id:
                 try:
                     table.cursor_coordinate = (
-                        table.get_row_index(selected_event_id),
+                        table.get_row_index(restore_event_id),
                         0,
                     )
                 except Exception:
@@ -913,12 +860,8 @@ class EventsTable(Container):
             else:
                 table.cursor_coordinate = (0, 0)
 
-        # Update pagination info
-        total_pages = self._get_total_pages()
-        pagination_widget = self.query_one("#pagination-info", Static)
-        pagination_widget.update(
-            f"[dim]Page {self.current_page}/{total_pages} ({self._total_events} total)  │  (p) prev  (n) next[/dim]"
-        )
+        # Clear saved cursor position after restore
+        self._saved_cursor_event_id = None
 
     def _shorten_id(self, event_id: str) -> str:
         """Shorten an event ID for display."""