pygpt-net 2.6.36__py3-none-any.whl → 2.6.38__py3-none-any.whl

pygpt_net/provider/api/x_ai/vision.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.05 01:00:00                  #
+# ================================================== #
+
+import os
+from typing import Optional, Dict, List
+
+from pygpt_net.item.attachment import AttachmentItem
+from pygpt_net.item.ctx import CtxItem
+
+
+class Vision:
+    def __init__(self, window=None):
+        """
+        Vision helpers for xAI (image inputs as data: URIs).
+
+        :param window: Window instance
+        """
+        self.window = window
+        self.attachments: Dict[str, str] = {}
+        self.urls: List[str] = []
+        self.input_tokens = 0
+        self.allowed_mimes = {"image/jpeg", "image/png"}
+
+    def build_images_for_chat(self, attachments: Optional[Dict[str, AttachmentItem]]) -> List[str]:
+        """
+        Build image inputs for xai_sdk.chat.image(...).
+        Returns list of image sources (URLs or data: URIs).
+
+        :param attachments: Attachments dict (id -> AttachmentItem)
+        :return: List of image sources
+        """
+        import base64
+
+        images: List[str] = []
+        self.attachments = {}
+        self.urls = []
+
+        if not attachments:
+            return images
+
+        for id_, att in (attachments or {}).items():
+            try:
+                if att.path and self.window.core.api.xai.vision.is_image(att.path):
+                    mime = self.window.core.api.xai.vision.guess_mime(att.path)
+                    # Accept only JPEG/PNG for SDK too (for consistency)
+                    #if mime not in self.allowed_mimes:
+                       # continue
+                    with open(att.path, "rb") as f:
+                        b64 = base64.b64encode(f.read()).decode("utf-8")
+                    images.append(f"data:{mime};base64,{b64}")
+                    self.attachments[id_] = att.path
+                    att.consumed = True
+            except Exception:
+                continue
+        return images
+
+    def is_image(self, path: str) -> bool:
+        """
+        Return True if path looks like an image file.
+
+        :param path: File path
+        """
+        return path.lower().endswith(('.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif', '.webp'))
+
+    def guess_mime(self, path: str) -> str:
+        """Guess MIME by extension.
+
+        :param path: File path
+        :return: MIME type string
+        """
+        ext = os.path.splitext(path)[1].lower().lstrip(".")
+        if ext in ("jpg", "jpeg"):
+            return "image/jpeg"
+        if ext == "png":
+            return "image/png"
+        if ext == "gif":
+            return "image/gif"
+        if ext == "bmp":
+            return "image/bmp"
+        if ext == "webp":
+            return "image/webp"
+        if ext == "tiff":
+            return "image/tiff"
+        return "image/jpeg"
+
+    def append_images(self, ctx: CtxItem):
+        """
+        Append sent images list to context for UI/history.
+
+        :param ctx: CtxItem
+        """
+        images = self.get_attachments()
+        if len(images) > 0:
+            ctx.images = self.window.core.filesystem.make_local_list(list(images.values()))
+
+    def get_attachments(self) -> Dict[str, str]:
+        return self.attachments
+
+    def get_urls(self) -> List[str]:
+        return self.urls
+
+    def reset_tokens(self):
+        self.input_tokens = 0
+
+    def get_used_tokens(self) -> int:
+        return self.input_tokens
+
+    def reset(self):
+        self.attachments = {}
+        self.urls = []
+        self.input_tokens = 0

pygpt_net/provider/core/attachment/json_file.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.16 01:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
 import json
@@ -162,7 +162,7 @@ class JsonFileProvider(BaseProvider):
             attachment.name = data['name']
         if 'path' in data:
             attachment.path = data['path']
-        if 'remote_id' in data:
+        if 'remote' in data:
             attachment.remote = data['remote']
         if 'send' in data:
             attachment.send = data['send']

pygpt_net/provider/core/config/patch.py

@@ -2447,6 +2447,34 @@ class Patch:
                 patch_css('web-blocks.css', True)
                 updated = True
 
+            # < 2.6.37
+            if old < parse_version("2.6.37"):
+                print("Migrating config from < 2.6.37...")
+
+                # add: label-desc CSS
+                patch_css('style.dark.css', True)
+                patch_css('style.light.css', True)
+
+                # add: Anthropic SDK
+                if "api_native_anthropic" not in data:
+                    data["api_native_anthropic"] = True
+                if "remote_tools.anthropic.web_search" not in data:
+                    data["remote_tools.anthropic.web_search"] = True
+
+                # add: xAI SDK
+                if "api_native_xai" not in data:
+                    data["api_native_xai"] = True
+                if "remote_tools.xai.mode" not in data:
+                    data["remote_tools.xai.mode"] = "auto"
+                if "remote_tools.xai.sources.web" not in data:
+                    data["remote_tools.xai.sources.web"] = True
+                if "remote_tools.xai.sources.x" not in data:
+                    data["remote_tools.xai.sources.x"] = True
+                if "remote_tools.xai.sources.news" not in data:
+                    data["remote_tools.xai.sources.news"] = False
+
+                updated = True
+
         # update file
         migrated = False
         if updated:

pygpt_net/provider/llms/anthropic.py

@@ -15,7 +15,7 @@ from llama_index.core.base.embeddings.base import BaseEmbedding
 from llama_index.core.llms.llm import BaseLLM as LlamaBaseLLM
 
 from pygpt_net.core.types import (
-    MODE_LLAMA_INDEX,
+    MODE_LLAMA_INDEX, MODE_CHAT,
 )
 from pygpt_net.provider.llms.base import BaseLLM
 from pygpt_net.item.model import ModelItem
@@ -93,7 +93,9 @@ class AnthropicLLM(BaseLLM):
         :param window: window instance
         :return: list of models
         """
-        client = window.core.api.anthropic.get_client()
+        model = ModelItem()
+        model.provider = "anthropic"
+        client = window.core.api.anthropic.get_client(MODE_CHAT, model)
         models_list = client.models.list()
         items = []
         if models_list.data:

pygpt_net/tools/text_editor/tool.py

@@ -183,16 +183,19 @@ class TextEditor(BaseTool):
         self.window.core.filesystem.editor.destroy(id)  # unregister from memory
         self.window.ui.dialogs.close(id)
 
-    def save(self, id: str) -> str:
+    def save(self, id: str, close: bool = False) -> str:
         """
         Save content to current file
 
         :param id: editor id
+        :param close: close editor after save
         :return: new editor id
         """
         file = self.window.ui.dialog[id].file
         if file:
             self.window.core.filesystem.editor.save(id)
+            if close:
+                self.close(id)
         else:
             id = self.save_as_file(id)
         return id

pygpt_net/tools/text_editor/ui/dialogs.py

@@ -47,7 +47,7 @@ class DialogSpawner:
             lambda: self.window.tools.get("editor").restore(id)
         )
         self.window.ui.nodes['editor.custom.btn.save'].clicked.connect(
-            lambda: self.window.tools.get("editor").save(id)
+            lambda: self.window.tools.get("editor").save(id, close=True)
         )
 
         bottom_layout = QHBoxLayout()

pygpt_net/ui/base/config_dialog.py

@@ -6,14 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.22 10:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QHBoxLayout, QLabel, QVBoxLayout, QSizePolicy, QWidget, QFrame
-from PySide6.QtGui import QFont
 
-from pygpt_net.ui.widget.element.labels import TitleLabel, UrlLabel
+from pygpt_net.ui.widget.element.labels import TitleLabel, UrlLabel, DescLabel, BaseLabel
 from pygpt_net.ui.widget.option.checkbox import OptionCheckbox
 from pygpt_net.ui.widget.option.checkbox_list import OptionCheckboxList
 from pygpt_net.ui.widget.option.combo import OptionCombo
@@ -123,7 +122,7 @@ class BaseConfigDialog:
         if extra.get('bold'):
             nodes[label_key] = TitleLabel(txt)
         else:
-            nodes[label_key] = QLabel(txt)
+            nodes[label_key] = BaseLabel(txt)
         nodes[label_key].setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
         nodes[label_key].setMinimumWidth(120)
         nodes[label_key].setWordWrap(True)
@@ -169,7 +168,7 @@ class BaseConfigDialog:
         if extra.get('bold'):
             nodes[label_key] = TitleLabel(txt)
         else:
-            nodes[label_key] = QLabel(txt)
+            nodes[label_key] = BaseLabel(txt)
         nodes[label_key].setMinimumHeight(30)
         nodes[label_key].setWordWrap(True)
 
@@ -234,12 +233,7 @@ class BaseConfigDialog:
         :param text: text (to translate)
         :return: QLabel
         """
-        desc = trans(text)
-        label = QLabel(desc)
-        label.setWordWrap(True)
-        label.setMaximumHeight(80)
-        label.setStyleSheet("font-size: 10px;")
-        return label
+        return DescLabel(trans(text))
 
     def add_urls(self, urls, align=Qt.AlignLeft) -> QWidget:
         """

pygpt_net/ui/dialog/db.py

@@ -6,13 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.24 23:00:00                  #
+# Updated Date: 2025.09.05 18:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QAction, QIcon
+from PySide6.QtCore import Qt, QTimer, QSignalBlocker
+from PySide6.QtGui import QAction, QIcon, QIntValidator
 from PySide6.QtWidgets import QGridLayout, QScrollArea, QSplitter, QComboBox, QLineEdit, QPushButton, \
-    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar
+    QHBoxLayout, QVBoxLayout, QLabel, QWidget, QSizePolicy, QCheckBox, QMenuBar, QAbstractItemView, QHeaderView, QStyledItemDelegate
 
 from pygpt_net.ui.widget.dialog.db import DatabaseDialog
 from pygpt_net.ui.widget.lists.db import DatabaseList, DatabaseTableModel
@@ -20,6 +20,18 @@ from pygpt_net.ui.widget.textarea.editor import CodeEditor
 from pygpt_net.utils import trans
 
 
+class _FastTextDelegate(QStyledItemDelegate):
+    def __init__(self, max_chars=1200, parent=None):
+        super().__init__(parent)
+        self.max_chars = max_chars
+
+    def displayText(self, value, locale):
+        s = "" if value is None else str(value)
+        if len(s) > self.max_chars:
+            return s[:self.max_chars] + "…"
+        return s
+
+
 class Database:
     def __init__(self, window=None):
         """
@@ -29,6 +41,8 @@ class Database:
         """
         self.window = window
         self.viewer = None
+        self._splitter_timer = None
+        self._text_viewer = None
 
     def setup(self, id: str = "db"):
         """
@@ -45,6 +59,7 @@ class Database:
         # data viewer
         text_viewer = CodeEditor(self.window)
         text_viewer.setReadOnly(False)
+        self._text_viewer = text_viewer
 
         self.window.ui.debug[id].browser = self.viewer
         self.window.ui.debug[id].viewer = text_viewer
@@ -63,6 +78,12 @@ class Database:
         splitter.addWidget(editor_widget)  # Value viewer
         splitter.setStretchFactor(0, 3)
         splitter.setStretchFactor(1, 1)
+        splitter.setOpaqueResize(False)
+
+        self._splitter_timer = QTimer(self.window)
+        self._splitter_timer.setSingleShot(True)
+        self._splitter_timer.timeout.connect(self._finish_splitter_move)
+        splitter.splitterMoved.connect(self._on_splitter_moved)
 
         self.menu_bar = QMenuBar()
         self.batch_actions_menu = self.menu_bar.addMenu("Actions")
@@ -81,6 +102,18 @@ class Database:
         self.window.ui.dialog['debug.db'].setLayout(layout)
         self.window.ui.dialog['debug.db'].setWindowTitle("Debug: Database (SQLite)")
 
+    def _on_splitter_moved(self, pos, index):
+        if self._text_viewer is not None:
+            self._text_viewer.setUpdatesEnabled(False)
+            self._splitter_timer.start(120)
+
+    def _finish_splitter_move(self):
+        if self._text_viewer is not None:
+            self._text_viewer.setUpdatesEnabled(True)
+            if hasattr(self._text_viewer, 'viewport'):
+                self._text_viewer.viewport().update()
+
+
 class DataBrowser(QWidget):
     def __init__(self, window=None):
         super().__init__()
@@ -111,7 +144,7 @@ class DataBrowser(QWidget):
 
         # buttons
         self.refresh_button = QPushButton(trans("db.refresh"))
-        self.refresh_button.clicked.connect(self.update_table_view)
+        self.refresh_button.clicked.connect(self.force_refresh)
         self.prev_button = QPushButton(trans("db.prev"))
         self.next_button = QPushButton(trans("db.next"))
         self.limit_input = QLineEdit("100")
@@ -126,7 +159,7 @@ class DataBrowser(QWidget):
         self.page_input_label = QLabel(trans("db.page") + ":")
         self.page_input_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
         self.page_input.editingFinished.connect(self.on_page_input_change)
-        self.page_info_label = QLabel(" / 1")  # total pages
+        self.page_info_label = QLabel(" / 1")
         self.page_info_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
 
         # checkboxes
@@ -155,18 +188,30 @@ class DataBrowser(QWidget):
         self.table_select.addItems(self.get_table_names())
         self.sort_order_select.addItems(['ASC', 'DESC'])
 
+        self._search_timer = QTimer(self)
+        self._search_timer.setSingleShot(True)
+        self._search_timer.timeout.connect(self.update_table_view)
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._cached_total_rows = 0
+        self._last_columns_sig = None
+
+        v = QIntValidator(1, 1000000000, self)
+        self.limit_input.setValidator(v)
+        self.page_input.setValidator(v)
+
         # signals
         self.table_select.currentIndexChanged.connect(self.on_table_select_changed)
         self.sort_by_select.currentIndexChanged.connect(self.update_table_view)
         self.sort_order_select.currentIndexChanged.connect(self.update_table_view)
-        self.search_input.textChanged.connect(self.update_table_view)
+        self.search_input.textChanged.connect(self.on_search_text_changed)
         self.search_column_select.currentIndexChanged.connect(self.update_table_view)
 
         self.prev_button.clicked.connect(self.prev_page)
         self.next_button.clicked.connect(self.next_page)
 
         self.table_select.setCurrentText(self.get_default_table())
-        self.on_table_select_changed()  # load data
+        self.on_table_select_changed()
 
         # setup layouts
         if not self.is_inline():
@@ -221,6 +266,27 @@ class DataBrowser(QWidget):
 
         self.setLayout(main_layout)
 
+        view = self.get_list_widget()
+        if hasattr(view, "setUniformRowHeights"):
+            view.setUniformRowHeights(True)
+        if hasattr(view, "setWordWrap"):
+            view.setWordWrap(False)
+        if hasattr(view, "setTextElideMode"):
+            view.setTextElideMode(Qt.ElideRight)
+        if hasattr(view, "setVerticalScrollMode"):
+            view.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
+        if hasattr(view, "setHorizontalScrollMode"):
+            view.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
+        if hasattr(view, "setViewportUpdateMode"):
+            view.setViewportUpdateMode(QAbstractItemView.MinimalViewportUpdate)
+        if hasattr(view, "horizontalHeader"):
+            hh = view.horizontalHeader()
+            if hh is not None:
+                hh.setSectionResizeMode(QHeaderView.Interactive)
+        self._fast_delegate = _FastTextDelegate(parent=view)
+        if hasattr(view, "setItemDelegate"):
+            view.setItemDelegate(self._fast_delegate)
+
     def is_inline(self) -> bool:
         return False
 
@@ -339,6 +405,8 @@ class DataBrowser(QWidget):
             self.limit_input.setText(str(current_limit))
             return
         self.current_offset = 0
+        self._last_fetch_sig = None
+        self._last_count_sig = None
         self.update_table_view()
 
     def get_page_size(self) -> int:
@@ -358,27 +426,18 @@ class DataBrowser(QWidget):
 
         :param update: Update table view
         """
-        page = int(self.page_input.text()) - 1
-        limit = int(self.limit_input.text())
-        search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(
-            current_table,
-            search_query=search_query,
-            search_column=search_column,
-            filters=self.get_filters(),
-        )
+        try:
+            page = int(self.page_input.text()) - 1
+        except ValueError:
+            page = 0
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
 
-        # check if page is in range
         if page * limit < total_rows and page >= 0:
             if update:
                 self.current_offset = page * limit
                 self.update_table_view()
         else:
-            # reset page
             current_page = self.current_offset // limit + 1
             self.page_input.setText(str(current_page))
 
@@ -395,38 +454,33 @@ class DataBrowser(QWidget):
         """Table select change event"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
-        self.sort_by_select.clear()
-        if current_table in tables:
-            self.sort_by_select.addItems(tables[current_table]['sort_by'])
-            self.sort_by_select.setCurrentText(tables[current_table]['default_sort'])
-            self.sort_order_select.setCurrentText(tables[current_table]['default_order'])
-            self.page_input.setText("1")  # reset page
-            self.on_page_input_change()
-            self.update_table_view()  # update view
-            self.update_search_columns()  # update search columns
+        with QSignalBlocker(self.sort_by_select), QSignalBlocker(self.sort_order_select):
+            self.sort_by_select.clear()
+            if current_table in tables:
+                self.sort_by_select.addItems(tables[current_table]['sort_by'])
+                self.sort_by_select.setCurrentText(tables[current_table]['default_sort'])
+                self.sort_order_select.setCurrentText(tables[current_table]['default_order'])
+        self.page_input.setText("1")
+        self.current_offset = 0
+        self.update_search_columns()
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._last_columns_sig = None
+        self.update_table_view()
 
     def update_search_columns(self):
         """Update search columns"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
-        self.search_column_select.clear()
-        self.search_column_select.addItem("*", None)
-        self.search_column_select.addItems(tables[current_table]['columns'])
+        with QSignalBlocker(self.search_column_select):
+            self.search_column_select.clear()
+            self.search_column_select.addItem("*", None)
+            self.search_column_select.addItems(tables[current_table]['columns'])
 
     def update_pagination_info(self):
         """Update pagination info"""
-        limit = int(self.limit_input.text())
-        search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(
-            current_table,
-            search_query=search_query,
-            search_column=search_column,
-            filters=self.get_filters(),
-        )
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
         total_pages = (total_rows - 1) // limit + 1
         self.page_info_label.setText(f" / {total_pages}  ({total_rows} rows)")
 
@@ -435,21 +489,24 @@ class DataBrowser(QWidget):
         self.prev_button.setEnabled(self.current_offset > 0)
         self.next_button.setEnabled(self.current_offset + limit < total_rows)
 
-    def update_table_view(self):
+    def update_table_view(self, *args, force: bool = False):
         """Update table view"""
         tables = self.get_tables()
         current_table = self.get_table_name(self.table_select.currentText())
         sort_by = self.sort_by_select.currentText()
         sort_order = self.sort_order_select.currentText()
         search_query = self.search_input.text()
-        search_column = self.search_column_select.currentText()
-        if search_column == "*":
-            search_column = None
-        limit = int(self.limit_input.text())
+        search_column = self.search_column_select.currentData()
+        limit = self.get_page_size()
 
         if current_table not in tables or sort_by == '' or sort_order == '' or limit <= 0:
             return
 
+        sig = self._params_signature_fetch()
+        if not force and self._last_fetch_sig == sig:
+            self.update_pagination_info()
+            return
+
         data = self.get_viewer().fetch_data(
             table=current_table,
             columns=tables[current_table]['columns'],
@@ -462,11 +519,12 @@ class DataBrowser(QWidget):
             filters=self.get_filters(),
         )
         self.load_data(data, tables[current_table])
+        self._last_fetch_sig = sig
         self.update_pagination_info()
 
     def prev_page(self):
         """Previous page event"""
-        limit = int(self.limit_input.text())
+        limit = self.get_page_size()
         if self.current_offset - limit >= 0:
             self.current_offset -= limit
         else:
@@ -475,10 +533,8 @@ class DataBrowser(QWidget):
 
     def next_page(self):
         """Next page event"""
-        limit = int(self.limit_input.text())
-        current_table = self.get_table_name(self.table_select.currentText())
-        total_rows = self.get_viewer().count_rows(current_table)
-
+        limit = self.get_page_size()
+        total_rows = self._get_total_rows()
         if self.current_offset + limit < total_rows:
             self.current_offset += limit
         self.update_table_view()
@@ -498,11 +554,73 @@ class DataBrowser(QWidget):
             self.db_path_label.setText(self.window.core.db.db_path)
         if not self.is_inline():
             convert_timestamps = self.convert_timestamps_checkbox.isChecked()
+        view = self.get_list_widget()
+        if hasattr(view, 'setSortingEnabled'):
+            view.setSortingEnabled(False)
+        view.setUpdatesEnabled(False)
         model = DatabaseTableModel(
             data,
             table['columns'],
             timestamp_columns=table.get('timestamp_columns', []),
             convert_timestamps=convert_timestamps,
         )
-        self.get_list_widget().setModel(model)
-        self.get_list_widget().adjustColumns()
+        if hasattr(model, 'setParent'):
+            model.setParent(view)
+        view.setModel(model)
+        if self._last_columns_sig != tuple(table['columns']):
+            if hasattr(view, 'adjustColumns'):
+                view.adjustColumns()
+            if hasattr(view, "horizontalHeader"):
+                hh = view.horizontalHeader()
+                if hh is not None:
+                    hh.setSectionResizeMode(QHeaderView.Interactive)
+            self._last_columns_sig = tuple(table['columns'])
+        view.setUpdatesEnabled(True)
+
+    def on_search_text_changed(self, text):
+        self._search_timer.start(200)
+
+    def _params_signature_base(self):
+        table = self.get_table_name(self.table_select.currentText())
+        search_query = self.search_input.text()
+        search_column = self.search_column_select.currentData()
+        filters = self.get_filters()
+        if isinstance(filters, dict):
+            filters_key = tuple(sorted(filters.items()))
+        else:
+            filters_key = str(filters)
+        return table, search_query, search_column, filters_key
+
+    def _params_signature_fetch(self):
+        table, search_query, search_column, filters_key = self._params_signature_base()
+        tables = self.get_tables()
+        columns = tuple(tables[table]['columns']) if table in tables else tuple()
+        sort_by = self.sort_by_select.currentText()
+        sort_order = self.sort_order_select.currentText()
+        limit = self.get_page_size()
+        offset = self.current_offset
+        return table, columns, sort_by, sort_order, search_query, search_column, filters_key, limit, offset
+
+    def _params_signature_count(self):
+        return self._params_signature_base()
+
+    def _get_total_rows(self):
+        sig = self._params_signature_count()
+        if self._last_count_sig == sig:
+            return self._cached_total_rows
+        table, search_query, search_column, _ = sig
+        total_rows = self.get_viewer().count_rows(
+            table,
+            search_query=search_query,
+            search_column=search_column,
+            filters=self.get_filters(),
+        )
+        self._last_count_sig = sig
+        self._cached_total_rows = total_rows
+        return total_rows
+
+    def force_refresh(self):
+        self._last_fetch_sig = None
+        self._last_count_sig = None
+        self._last_columns_sig = None
+        self.update_table_view()