pygpt-net 2.6.47__py3-none-any.whl → 2.6.49__py3-none-any.whl

pygpt_net/provider/core/config/patch.py

@@ -88,6 +88,15 @@ class Patch:
                 patch_css('web-chatgpt_wide.light.css', True)
                 updated = True
 
+            # < 2.6.48
+            if old < parse_version("2.6.48"):
+                print("Migrating config from < 2.6.48...")
+                # reformat
+                patch_css('web-chatgpt.css', True)
+                patch_css('web-chatgpt_wide.css', True)
+                patch_css('web-blocks.css', True)
+                updated = True
+
         # update file
         migrated = False
         if updated:

pygpt_net/provider/core/ctx/db_sqlite/storage.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.14 22:00:00                  #
+# Updated Date: 2025.09.15 22:00:00                  #
 # ================================================== #
 
 from datetime import datetime
@@ -109,6 +109,12 @@ class Storage:
                     continue
                 mode = filter.get('mode', '=')
                 value = filter.get('value', '')
+
+                # handle special case for "ungrouped" (group_id IS NULL OR = 0)
+                if key == 'group_id' and str(mode).upper() == 'NULL_OR_ZERO':
+                    where_clauses.append("(m.group_id IS NULL OR m.group_id = 0)")
+                    continue
+
                 key_name = 'm.' + key
                 if isinstance(value, int):
                     where_clauses.append(f"{key_name} {mode} :{key}")
@@ -116,7 +122,7 @@ class Storage:
                 elif isinstance(value, str):
                     where_clauses.append(f"{key_name} {mode} :{key}")
                     bind_params[key] = f"%{value}%"
-                elif isinstance(value, list):
+                elif isinstance(value, list) and len(value) > 0:
                     values = "(" + ",".join([str(x) for x in value]) + ")"
                     where_clauses.append(f"{key_name} {mode} {values}")
 
@@ -148,15 +154,21 @@ class Storage:
         :return: dict of CtxMeta
         """
         limit_suffix = ""
-        if limit is not None and limit > 0:
-            limit_suffix = " LIMIT {}".format(limit)
-
         where_statement, join_statement, bind_params = self.prepare_query(
             search_string=search_string,
             filters=filters,
             search_content=search_content,
             append_date_ranges=True,
         )
+
+        # Build LIMIT/OFFSET only when limit > 0; LIMIT 0 would mean "no rows"
+        if limit is not None and int(limit) > 0:
+            limit_suffix = " LIMIT :limit"
+            bind_params['limit'] = int(limit)
+            if offset is not None and int(offset) > 0:
+                limit_suffix += " OFFSET :offset"
+                bind_params['offset'] = int(offset)
+
         stmt_text = f"""
             SELECT 
                 m.*,
@@ -168,6 +180,8 @@ class Storage:
                 {join_statement} 
             WHERE 
                 {where_statement}
+            GROUP BY 
+                m.id
             ORDER BY 
                 m.updated_ts DESC {limit_suffix}
         """

pygpt_net/tools/code_interpreter/ui/html.py

@@ -6,16 +6,16 @@
 # 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.16 02:00:00                  #
 # ================================================== #
 
 import json
 import re
 from typing import Optional
 
-from PySide6.QtCore import Qt, QObject, Signal, Slot, QEvent, QTimer
+from PySide6.QtCore import Qt, QObject, Signal, Slot, QEvent, QTimer, QUrl, QCoreApplication, QEventLoop
 from PySide6.QtWebChannel import QWebChannel
-from PySide6.QtWebEngineCore import QWebEngineSettings, QWebEnginePage
+from PySide6.QtWebEngineCore import QWebEngineSettings, QWebEnginePage, QWebEngineProfile
 from PySide6.QtWebEngineWidgets import QWebEngineView
 from PySide6.QtGui import QAction, QIcon, QKeySequence
 from PySide6.QtWidgets import QMenu
@@ -25,6 +25,7 @@ from pygpt_net.core.text.web_finder import WebFinder
 from pygpt_net.tools.code_interpreter.body import Body
 from pygpt_net.utils import trans
 
+
 class CodeBlock:
     def __init__(
             self,
@@ -109,32 +110,119 @@ class HtmlOutput(QWebEngineView):
         self.is_dialog = False
         self.nodes = []  # code blocks
 
+        # OpenGL widgets
+        self._glwidget = None
+        self._glwidget_filter_installed = False
+        self._unloaded = False  # flag to check if unloaded
+        self._destroyed = False
+
+        # self._profile = self._make_profile(self)
+        self.setPage(CustomWebEnginePage(self.window, self, profile=None))
+
+    def _make_profile(self, parent=None) -> QWebEngineProfile:
+        """Make profile"""
+        profile = QWebEngineProfile()
+        profile.setPersistentCookiesPolicy(QWebEngineProfile.NoPersistentCookies)
+        profile.setSpellCheckEnabled(False)
+        return profile
+
+    def _detach_gl_event_filter(self):
+        """Detach OpenGL widget event filter if installed"""
+        if self._glwidget and self._glwidget_filter_installed:
+            try:
+                self._glwidget.removeEventFilter(self)
+            except Exception as e:
+                self._on_delete_failed(e)
+        self._glwidget = None
+        self._glwidget_filter_installed = False
+
+    def _on_delete_failed(self, e):
+        """
+        Handle delete failure
+
+        :param e: Exception instance
+        """
+        pass
+        # self.window.core.debug.log(e)
+
+    def unload(self):
+        """Unload the current page and free resources"""
+        try:
+            self.hide()
+            p = self.page()
+            p.triggerAction(QWebEnginePage.Stop)
+            p.setUrl(QUrl("about:blank"))
+            p.history().clear()
+            p.setLifecycleState(QWebEnginePage.LifecycleState.Discarded)
+        except Exception as e:
+            self._on_delete_failed(e)
+        finally:
+            self._unloaded = True
+
     def on_delete(self):
         """Clean up on delete"""
+        if self._destroyed:
+            return
+        if not self._unloaded:
+            self.unload()
+
+        self.hide()
+        self._detach_gl_event_filter()
+
         if self.finder:
-            self.finder.disconnect()  # disconnect finder
-            self.finder = None  # delete finder
+            try:
+                self.finder.disconnect()
+            except Exception as e:
+                self._on_delete_failed(e)
+            finally:
+                self.finder = None
 
-        self.tab = None  # clear tab reference
+        self.tab = None
+        self.meta = None
 
-        # delete page
         page = self.page()
-        if page:
-            if hasattr(page, 'bridge'):
-                page.bridge.deleteLater()
-            if hasattr(page, 'channel'):
-                page.channel.deleteLater()
-            if hasattr(page, 'signals') and page.signals:
-                page.signals.deleteLater()
-            page.deleteLater()  # delete page
+        prof = page.profile()
 
         # disconnect signals
-        self.loadFinished.disconnect(self.on_page_loaded)
-        self.customContextMenuRequested.disconnect(self.on_context_menu)
-        self.signals.save_as.disconnect(self.window.controller.chat.render.handle_save_as)
-        self.signals.audio_read.disconnect(self.window.controller.chat.render.handle_audio_read)
+        try:
+            self.loadFinished.disconnect()
+            self.customContextMenuRequested.disconnect()
+            self.signals.save_as.disconnect()
+            self.signals.audio_read.disconnect()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            if hasattr(page, "setWebChannel"):
+                page.setWebChannel(None)
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            page.cleanup()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        """
+        if prof is not None:
+            try:
+                prof.deleteLater()
+            except Exception as e:
+                self._on_delete_failed(e)
+        """
+
+        try:
+            self.deleteLater()
+        except Exception as e:
+            self._on_delete_failed(e)
+
+        try:
+            QCoreApplication.sendPostedEvents(None, QEvent.DeferredDelete)
+            QCoreApplication.processEvents(QEventLoop.AllEvents, 50)
+        except Exception as e:
+            self._on_delete_failed(e)
 
-        self.deleteLater()  # delete widget
+        self._destroyed = True
 
     def init(self, force: bool = False):
         """
@@ -164,7 +252,7 @@ class HtmlOutput(QWebEngineView):
 
     def reload(self):
         """Reload HTML output"""
-        #return
+        # return
         self.reload_css()
 
     def get_nodes(self) -> list:
@@ -203,7 +291,7 @@ class HtmlOutput(QWebEngineView):
 
         :param text: text
         """
-        self.plain+= str(text)
+        self.plain += str(text)
 
     def set_plaintext(self, text: str):
         """
@@ -267,7 +355,7 @@ class HtmlOutput(QWebEngineView):
             if node.content != "":
                 self.nodes.append(node)
                 if self.loaded:
-                        self.insert_output(node)
+                    self.insert_output(node)
         self.update_current_content()
         QTimer.singleShot(100, self.scroll_to_bottom)  # wait for rendering to complete
 
@@ -508,7 +596,7 @@ class HtmlOutput(QWebEngineView):
         menu.addSeparator()
         action = QAction(QIcon(":/icons/search.svg"), trans('text.context_menu.find'), self)
         action.triggered.connect(self.find_open)
-        #action.setShortcut(QKeySequence("Ctrl+F"))
+        # action.setShortcut(QKeySequence("Ctrl+F"))
         menu.addAction(action)
 
         menu.exec_(self.mapToGlobal(position))
@@ -615,14 +703,20 @@ class HtmlOutput(QWebEngineView):
         if (event.type() == QEvent.ChildAdded and
                 source is self and
                 event.child().isWidgetType()):
+            self._detach_gl_event_filter()
             self._glwidget = event.child()
-            self._glwidget.installEventFilter(self)
+            try:
+                self._glwidget.installEventFilter(self)
+                self._glwidget_filter_installed = True
+            except Exception:
+                self._glwidget = None
+                self._glwidget_filter_installed = False
         elif event.type() == event.Type.MouseButtonPress:
             if self.tab:
                 col_idx = self.tab.column_idx
                 self.window.controller.ui.tabs.on_column_focus(col_idx)
         elif event.type() == event.Type.FocusIn:
-            if self.tab is not None:
+            if self.tab:
                 col_idx = self.tab.column_idx
                 self.window.controller.ui.tabs.on_column_focus(col_idx)
         elif event.type() == QEvent.KeyPress:
@@ -633,10 +727,17 @@ class HtmlOutput(QWebEngineView):
 
 class CustomWebEnginePage(QWebEnginePage):
     """Custom WebEnginePage to handle web events"""
-    def __init__(self, window, parent):
-        super(CustomWebEnginePage, self).__init__(window)
+
+    def __init__(self, window, view, profile: QWebEngineProfile = None):
+
+        # use the profile if provided, otherwise the default
+        if profile is not None:
+            super(CustomWebEnginePage, self).__init__(profile, view)
+        else:
+            super(CustomWebEnginePage, self).__init__(view)
+
         self.window = window
-        self.parent = parent
+        self.parent = view
         self.signals = WebEnginePageSignals()
         self.findTextFinished.connect(self.on_find_finished)
         self.zoomFactorChanged.connect(self.on_view_changed)
@@ -687,7 +788,7 @@ class CustomWebEnginePage(QWebEnginePage):
         """On selection changed"""
         pass
 
-    def acceptNavigationRequest(self, url,  _type, isMainFrame):
+    def acceptNavigationRequest(self, url, _type, isMainFrame):
         """
         On navigation (link click) event
 
@@ -698,7 +799,7 @@ class CustomWebEnginePage(QWebEnginePage):
         if _type == QWebEnginePage.NavigationTypeLinkClicked:
             self.window.core.filesystem.url.handle(url)
             return False
-        return super().acceptNavigationRequest(url,  _type, isMainFrame)
+        return super().acceptNavigationRequest(url, _type, isMainFrame)
 
     def javaScriptConsoleMessage(self, level, message, line_number, source_id):
         """
@@ -711,9 +812,40 @@ class CustomWebEnginePage(QWebEnginePage):
         """
         self.signals.js_message.emit(line_number, message, source_id)  # handled in debug controller
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        try:
+            self.findTextFinished.disconnect()
+            self.zoomFactorChanged.disconnect()
+            self.selectionChanged.disconnect()
+        except Exception:
+            pass
+
+        if self.bridge:
+            try:
+                self.bridge.cleanup()
+            except Exception:
+                pass
+            self.bridge = None
+
+        if self.channel:
+            try:
+                self.channel.unregisterObject("bridge")
+            except Exception:
+                pass
+            self.channel = None
+
+        if self.signals:
+            try:
+                self.signals.deleteLater()
+            except Exception:
+                pass
+            self.signals = None
+
 
 class Bridge(QObject):
     """Bridge between Python and JavaScript"""
+
     def __init__(self, window):
         super(Bridge, self).__init__(window)
         self.window = window
@@ -754,10 +886,23 @@ class Bridge(QObject):
         """
         self.window.controller.chat.render.scroll = pos
 
+    def cleanup(self):
+        """Cleanup method to release resources"""
+        if self.window:
+            try:
+                self.window = None
+            except Exception:
+                pass
+
+        # delete the bridge object
+        self.deleteLater()
+
+
 class WebEngineSignals(QObject):
     save_as = Signal(str, str)
     audio_read = Signal(str)
 
+
 class WebEnginePageSignals(QObject):
     js_message = Signal(int, str, str)  # on Javascript message
 

pygpt_net/tools/code_interpreter/ui/widgets.py

@@ -6,7 +6,7 @@
 # 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.16 02:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
@@ -100,9 +100,6 @@ class ToolWidget:
         :return: QVBoxLayout
         """
         self.output = HtmlOutput(self.window, self.tool)
-        self.output.setPage(
-            CustomWebEnginePage(self.window, self.output)
-        )
         self.output.signals.save_as.connect(self.window.controller.chat.render.handle_save_as)
         self.output.signals.audio_read.connect(self.window.controller.chat.render.handle_audio_read)
 

pygpt_net/tools/html_canvas/ui/widgets.py

@@ -6,7 +6,7 @@
 # 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.16 02:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt, Slot, QUrl, QObject, Signal
@@ -14,7 +14,7 @@ from PySide6.QtWidgets import QVBoxLayout, QCheckBox, QHBoxLayout
 
 from pygpt_net.ui.widget.element.labels import HelpLabel
 from pygpt_net.ui.widget.textarea.editor import BaseCodeEditor
-from pygpt_net.ui.widget.textarea.html import HtmlOutput, CustomWebEnginePage
+from pygpt_net.ui.widget.textarea.html import HtmlOutput
 from pygpt_net.utils import trans
 
 
@@ -61,9 +61,6 @@ class ToolWidget:
         :return: QVBoxLayout
         """
         self.output = CanvasOutput(self.window)
-        self.output.setPage(
-            CustomWebEnginePage(self.window, self.output)
-        )
         self.edit = CanvasEdit(self.window)
         self.edit.setVisible(False)
         self.edit.textChanged.connect(

pygpt_net/ui/__init__.py

@@ -16,13 +16,13 @@ from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QFontDatabase, QIcon
 from PySide6.QtWidgets import QSplitter, QMessageBox
 
-from pygpt_net.ui.base.context_menu import ContextMenu
-from pygpt_net.ui.dialogs import Dialogs
-from pygpt_net.ui.layout.chat import ChatMain
-from pygpt_net.ui.layout.ctx import CtxMain
-from pygpt_net.ui.layout.toolbox import ToolboxMain
-from pygpt_net.ui.menu import Menu
-from pygpt_net.ui.tray import Tray
+from .base.context_menu import ContextMenu
+from .dialogs import Dialogs
+from .layout.chat import ChatMain
+from .layout.ctx import CtxMain
+from .layout.toolbox import ToolboxMain
+from .menu import Menu
+from .tray import Tray
 
 
 class UI:
@@ -139,12 +139,7 @@ class UI:
         suffix = self.window.core.platforms.get_env_suffix()
         profile_name = self.window.core.config.profile.get_current_name()
         self.window.setWindowTitle(
-            'PyGPT - Desktop AI Assistant {} | build {}{} ({})'.format(
-                self.window.meta['version'],
-                self.window.meta['build'].replace('.', '-'),
-                suffix,
-                profile_name,
-            )
+            f"PyGPT - Desktop AI Assistant {self.window.meta['version']} | build {self.window.meta['build'].replace('.', '-')}{suffix} ({profile_name})"
         )
 
     def post_setup(self):
@@ -164,7 +159,7 @@ class UI:
             return
         msg = str(text)
         msg = msg.replace("\n", " ")
-        status = msg[:self.STATUS_MAX_CHARS] + '...' if len(msg) > self.STATUS_MAX_CHARS else msg  # truncate
+        status = f"{msg[:self.STATUS_MAX_CHARS]}..." if len(msg) > self.STATUS_MAX_CHARS else msg  # truncate
         self.nodes['status'].setText(status)
 
     def get_status(self):

pygpt_net/ui/layout/chat/chat.py

@@ -12,8 +12,8 @@
 from PySide6.QtCore import Qt, Slot
 from PySide6.QtWidgets import QSplitter
 
-from pygpt_net.ui.layout.chat.input import Input
-from pygpt_net.ui.layout.chat.output import Output
+from .input import Input
+from .output import Output
 
 
 class ChatMain:

pygpt_net/ui/layout/ctx/ctx_list.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.12 23:00:00                  #
+# Updated Date: 2025.09.15 22:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
@@ -113,9 +113,79 @@ class CtxList:
                     self.update_items_pinned(id, data)
                     self.update_items(id, data)
                     self.update_groups(id, data, expand=expand)
+
+                # APPLY PENDING SCROLL BEFORE RE-ENABLING UPDATES (prevents top flicker)
+                try:
+                    node.apply_pending_scroll()
+                    node.clear_pending_scroll()
+                except Exception:
+                    pass
             finally:
                 node.setUpdatesEnabled(True)
 
+    def _find_first_group_row(self, model) -> int:
+        """Find the row index of the first GroupItem; return -1 if none."""
+        for r in range(model.rowCount()):
+            it = model.item(r)
+            if isinstance(it, GroupItem):
+                return r
+        return -1
+
+    def append_unpaginated(self, id: str, data: dict, add_ids: list[int]):
+        """
+        Append more ungrouped and not pinned items without rebuilding the model.
+        Keeps scroll position perfectly stable.
+        """
+        if not add_ids:
+            return
+        node = self.window.ui.nodes[id]
+        model = self.window.ui.models[id]
+
+        folders_top = bool(self.window.core.config.get("ctx.records.folders.top"))
+        # decide insertion point: at the end, or just before the first group row
+        insert_pos = model.rowCount()
+        if not folders_top:
+            grp_idx = self._find_first_group_row(model)
+            insert_pos = grp_idx if grp_idx >= 0 else model.rowCount()
+
+        # find last dt of existing ungrouped area before insertion point (for date sections)
+        last_dt_str = None
+        for r in range(insert_pos - 1, -1, -1):
+            it = model.item(r)
+            if isinstance(it, Item):
+                data_role = it.data(QtCore.Qt.ItemDataRole.UserRole) or {}
+                if not data_role.get("in_group", False) and not data_role.get("is_important", False):
+                    last_dt_str = getattr(it, "dt", None)
+                    break
+            elif isinstance(it, GroupItem):
+                break  # hit groups boundary going upwards
+            else:
+                # SectionItem or others – skip
+                continue
+
+        node.setUpdatesEnabled(False)
+        try:
+            # append strictly in the order provided by add_ids (older first)
+            for mid in add_ids:
+                meta = data.get(mid)
+                if meta is None:
+                    continue
+                item = self.build_item(mid, meta, is_group=False)
+
+                # Optional date sections (same logic as in update_items)
+                if self._group_separators and (not item.isPinned or self._pinned_separators):
+                    if last_dt_str is None or last_dt_str != item.dt:
+                        section = self.build_date_section(item.dt, group=False)
+                        if section:
+                            model.insertRow(insert_pos, section)
+                            insert_pos += 1
+                        last_dt_str = item.dt
+
+                model.insertRow(insert_pos, item)
+                insert_pos += 1
+        finally:
+            node.setUpdatesEnabled(True)
+
     def update_items(self, id, data):
         """
         Update items

pygpt_net/ui/widget/lists/base.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.19 17:00:00                  #
+# Updated Date: 2025.09.15 22:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QItemSelectionModel
@@ -36,6 +36,10 @@ class BaseList(QTreeView):
         self.v_scroll_value = 0
         self.h_scroll_value = 0
 
+        # pending scroll values applied while updates are disabled (to avoid top flicker)
+        self._pending_v_scroll_value = None
+        self._pending_h_scroll_value = None
+
     def click(self, val):
         self.window.controller.mode.select(self.id)
         self.selection = self.selectionModel().selection()
@@ -103,3 +107,30 @@ class BaseList(QTreeView):
         """Restore scroll position"""
         self.verticalScrollBar().setValue(self.v_scroll_value)
         self.horizontalScrollBar().setValue(self.h_scroll_value)
+
+    def set_pending_v_scroll(self, value: int):
+        """
+        Set vertical scroll value to apply while updates are disabled.
+        This prevents a visible jump to the top during model rebuild.
+        """
+        self._pending_v_scroll_value = int(value)
+
+    def set_pending_h_scroll(self, value: int):
+        """Optional: set horizontal pending value."""
+        self._pending_h_scroll_value = int(value)
+
+    def clear_pending_scroll(self):
+        """Clear pending scroll values."""
+        self._pending_v_scroll_value = None
+        self._pending_h_scroll_value = None
+
+    def apply_pending_scroll(self):
+        """
+        Apply pending scroll values immediately.
+        IMPORTANT: Call this before re-enabling updates to avoid repaint at top.
+        """
+        if self._pending_v_scroll_value is not None:
+            self.verticalScrollBar().setValue(self._pending_v_scroll_value)
+        if self._pending_h_scroll_value is not None:
+            self.horizontalScrollBar().setValue(self._pending_h_scroll_value)
+        # do not clear here; let caller decide when to clear