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

pygpt_net/controller/ui/tabs.py

@@ -6,14 +6,12 @@
 # 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 gc
-from typing import Any, Optional, Tuple
 
-from PySide6.QtCore import QTimer, QUrl
-from PySide6.QtWebEngineCore import QWebEnginePage
+from typing import Any, Optional, Tuple
 
+from PySide6.QtCore import QTimer
 from pygpt_net.core.events import AppEvent, RenderEvent
 from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.item.ctx import CtxMeta
@@ -134,46 +132,15 @@ class Tabs:
 
     def reload(self):
         """Reload tabs"""
-        self.unload_current()
+        columns = self.window.ui.layout.columns
+        for col in columns:
+            col.setUpdatesEnabled(False)
+        self.window.core.tabs.remove_all()
         self.window.core.tabs.reload()
         self.window.dispatch(RenderEvent(RenderEvent.PREPARE))
         self.debug()
-
-    def unload_current(self):
-        """Unload current tabs from memory"""
-        tabs = self.window.core.tabs.pids
-        for pid in tabs:
-            tab = self.window.core.tabs.get_tab_by_pid(pid)
-            if tab is not None:
-                try:
-                    if tab.type == Tab.TAB_CHAT:
-                        node = self.window.ui.nodes['output'].get(tab.pid)
-                        if node:
-                            node.hide()
-                            p = node.page()
-                            p.triggerAction(QWebEnginePage.Stop)
-                            p.setUrl(QUrl("about:blank"))
-                            p.history().clear()
-                            p.setLifecycleState(QWebEnginePage.LifecycleState.Discarded)
-                            tab.delete_ref(node)
-                            layout = tab.child.layout()
-                            layout.removeWidget(node)
-                            self.window.ui.nodes['output'].pop(pid, None)
-                            node.on_delete()
-                        node_plain = self.window.ui.nodes['output_plain'].get(tab.pid)
-                        if node_plain:
-                            tab.delete_ref(node_plain)
-                            layout = tab.child.layout()
-                            layout.removeWidget(node_plain)
-                            self.window.ui.nodes['output_plain'].pop(pid, None)
-                            node_plain.on_delete()
-                    tab.cleanup()
-                except Exception as e:
-                    print(f"Error unloading tab {pid}: {e}")
-        try:
-            gc.collect()
-        except Exception:
-            pass
+        for col in columns:
+            col.setUpdatesEnabled(True)
 
     def reload_after(self):
         """Reload tabs after"""
@@ -394,7 +361,7 @@ class Tabs:
         if tab.type == Tab.TAB_CHAT and self.column_idx == 1 and not getattr(tab, "loaded", False):
             meta = self.window.core.ctx.get_meta_by_id(tab.data_id)
             if meta is not None:
-                self.window.controller.ctx.load(meta.id)
+                self.window.controller.ctx.load(meta.id, no_fresh=True)
             tab.loaded = True
 
         current_ctx = self.window.core.ctx.get_current()

pygpt_net/core/ctx/ctx.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 02:00:00                  #
+# Updated Date: 2025.09.15 22:00:00                  #
 # ================================================== #
 
 import copy
@@ -1003,7 +1003,7 @@ class Ctx:
         for item in reversed(history_items):
             num = from_ctx(item, mode, model)
             new_total = tokens + num
-            if max_tokens > 0 and new_total > max_tokens:
+            if 0 < max_tokens < new_total:
                 break
             tokens = new_total
             context_tokens += num
@@ -1240,49 +1240,102 @@ class Ctx:
         return len(self.filters_labels) < num_all
 
     def load_meta(self):
-        """Load ctx list from provider"""
-        limit = 0
+        """Load ctx list: pinned and grouped unlimited; ungrouped not pinned paginated directly in SQL."""
+        # base package size (per page)
+        base_limit = 0
         if self.window.core.config.has('ctx.records.limit'):
-            limit = int(self.window.core.config.get('ctx.records.limit') or 0)
-
-        if "is_important" not in self.filters and "indexed_ts" not in self.filters:
-            filters_pinned = self.get_parsed_filters()
-            filters_pinned['is_important'] = {
-                "mode": "=",
-                "value": 1,
-            }
-            meta_pinned = self.provider.get_meta(
+            try:
+                base_limit = int(self.window.core.config.get('ctx.records.limit') or 0)
+            except Exception:
+                base_limit = 0
+
+        # total loaded (persisted); fallback to base when missing
+        try:
+            loaded_total = int(self.window.core.config.get('ctx.records.limit.total') or 0)
+        except Exception:
+            loaded_total = 0
+        if loaded_total <= 0:
+            loaded_total = base_limit
+
+        # Common filters (labels etc.)
+        common_filters = self.get_parsed_filters()
+
+        # If explicit filters target a narrow subset (legacy path), keep old behavior
+        if "is_important" in self.filters or "indexed_ts" in self.filters:
+            limit = 0 if base_limit == 0 else loaded_total
+            self.meta = self.provider.get_meta(
                 search_string=self.search_string,
                 order_by='updated_ts',
                 order_direction='DESC',
-                limit=0,
-                filters=filters_pinned,
+                limit=limit,
+                offset=0,
+                filters=common_filters,
                 search_content=self.is_search_content(),
             )
+            return
 
-            filters = self.get_parsed_filters()
-            meta_unpinned = self.provider.get_meta(
+        # 1) Pinned (important) – unlimited
+        filters_pinned = self.get_parsed_filters()
+        filters_pinned['is_important'] = {"mode": "=", "value": 1}
+        meta_pinned = self.provider.get_meta(
+            search_string=self.search_string,
+            order_by='updated_ts',
+            order_direction='DESC',
+            limit=0,
+            offset=0,
+            filters=filters_pinned,
+            search_content=self.is_search_content(),
+        )
+
+        # 2) Grouped – unlimited
+        filters_grouped = self.get_parsed_filters()
+        filters_grouped['group_id'] = {"mode": ">", "value": 0}
+        meta_grouped = self.provider.get_meta(
+            search_string=self.search_string,
+            order_by='updated_ts',
+            order_direction='DESC',
+            limit=0,
+            offset=0,
+            filters=filters_grouped,
+            search_content=self.is_search_content(),
+        )
+
+        # 3) Ungrouped & not pinned – paginate directly in SQL
+        #    If base_limit == 0 -> unlimited (no paging)
+        filters_ungrp = self.get_parsed_filters()
+        filters_ungrp['is_important'] = {"mode": "=", "value": 0}
+        filters_ungrp['group_id'] = {"mode": "NULL_OR_ZERO", "value": 0}  # special mode handled in Storage
+
+        if base_limit <= 0:
+            meta_ungrouped = self.provider.get_meta(
                 search_string=self.search_string,
                 order_by='updated_ts',
                 order_direction='DESC',
-                limit=limit,
-                filters=filters,
+                limit=0,         # unlimited
+                offset=0,
+                filters=filters_ungrp,
                 search_content=self.is_search_content(),
             )
-
-            self.meta = {**meta_pinned, **meta_unpinned}
-
         else:
-            filters = self.get_parsed_filters()
-            self.meta = self.provider.get_meta(
+            # Always take the top-N ungrouped newest items directly from DB
+            take = max(0, int(loaded_total or 0))
+            meta_ungrouped = self.provider.get_meta(
                 search_string=self.search_string,
                 order_by='updated_ts',
                 order_direction='DESC',
-                limit=limit,
-                filters=filters,
+                limit=take,
+                offset=0,
+                filters=filters_ungrp,
                 search_content=self.is_search_content(),
             )
 
+        # Compose final dict with deterministic order: pinned -> grouped -> ungrouped
+        combined = {}
+        combined.update(meta_pinned)
+        combined.update(meta_grouped)
+        combined.update(meta_ungrouped)
+        self.meta = combined
+
     def load_tmp_meta(self, meta_id: int):
         """
         Load tmp meta

pygpt_net/core/render/web/renderer.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.14 20:00:00                  #
+# Updated Date: 2025.09.16 02:00:00                  #
 # ================================================== #
 
 import gc
@@ -1274,12 +1274,7 @@ class Renderer(BaseRenderer):
                     pass
             self._bridge_ready[pid] = False
             self._pending_nodes[pid] = []
-            node.hide()
-            p = node.page()
-            p.triggerAction(QWebEnginePage.Stop)
-            p.setUrl(QUrl("about:blank"))
-            p.history().clear()
-            p.setLifecycleState(QWebEnginePage.LifecycleState.Discarded)
+            node.unload()  # unload web page
             self._stream_reset(pid)
             self.pids[pid].clear(all=True)
             self.pids[pid].loaded = False
@@ -1294,9 +1289,8 @@ class Renderer(BaseRenderer):
         :param meta: context meta
         """
         tab = node.get_tab()
-        tab.delete_ref(node)
         layout = tab.child.layout()
-        layout.removeWidget(node)
+        tab.child.remove_widget(node)
         self.window.ui.nodes['output'].pop(tab.pid, None)
 
         node.on_delete()
@@ -1307,7 +1301,7 @@ class Renderer(BaseRenderer):
         view.signals.save_as.connect(self.window.controller.chat.render.handle_save_as)
         view.signals.audio_read.connect(self.window.controller.chat.render.handle_audio_read)
 
-        layout.addWidget(view)
+        layout.addWidget(view)  # tab body layout
         view.setVisible(True)
         self.window.ui.nodes['output'][tab.pid] = view
         try:

pygpt_net/core/tabs/tabs.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                  #
 # ================================================== #
 
 import uuid
@@ -234,20 +234,38 @@ class Tabs:
             tab.icon = self.icons[tab.type]
 
         if tab.type == Tab.TAB_CHAT:  # chat
-            self.add_chat(tab)
-            self.window.core.ctx.output.mapping[tab.pid] = tab.data_id  # restore pid => meta.id mapping
-            self.window.core.ctx.output.last_pids[tab.data_id] = tab.pid
-            self.window.core.ctx.output.last_pid = tab.pid
+            try:
+                self.add_chat(tab)
+                self.window.core.ctx.output.mapping[tab.pid] = tab.data_id  # restore pid => meta.id mapping
+                self.window.core.ctx.output.last_pids[tab.data_id] = tab.pid
+                self.window.core.ctx.output.last_pid = tab.pid
+            except Exception as e:
+                print("Error restoring chat tab:", e)
         elif tab.type == Tab.TAB_NOTEPAD: # notepad
-            self.add_notepad(tab)
+            try:
+                self.add_notepad(tab)
+            except Exception as e:
+                print("Error restoring notepad tab:", e)
         elif tab.type == Tab.TAB_FILES:  # files
-            self.add_tool_explorer(tab)
+            try:
+                self.add_tool_explorer(tab)
+            except Exception as e:
+                print("Error restoring explorer tab:", e)
         elif tab.type == Tab.TAB_TOOL_PAINTER:  # painter
-            self.add_tool_painter(tab)
+            try:
+                self.add_tool_painter(tab)
+            except Exception as e:
+                print("Error restoring painter tab:", e)
         elif tab.type == Tab.TAB_TOOL_CALENDAR:  # calendar
-            self.add_tool_calendar(tab)
+            try:
+                self.add_tool_calendar(tab)
+            except Exception as e:
+                print("Error restoring calendar tab:", e)
         elif tab.type == Tab.TAB_TOOL:  # custom tools, id 100+
-            self.add_tool(tab)
+            try:
+                self.add_tool(tab)
+            except Exception as e:
+                print("Error restoring tool tab:", e)
 
         self.pids[tab.pid] = tab
         self.last_pid = self.get_max_pid()
@@ -277,8 +295,29 @@ class Tabs:
         tab = self.get_tab_by_pid(pid)
         if tab is None:
             return
+        try:
+            if tab.type == Tab.TAB_CHAT:
+                node = self.window.ui.nodes['output'].get(tab.pid)
+                if node:
+                    node.unload()  # unload web page
+                    tab.child.remove_widget(node)
+                    self.window.ui.nodes['output'].pop(pid, None)
+                    node.on_delete()
+                node_plain = self.window.ui.nodes['output_plain'].get(tab.pid)
+                if node_plain:
+                    tab.child.remove_widget(node_plain)
+                    self.window.ui.nodes['output_plain'].pop(pid, None)
+                    node_plain.on_delete()
+
+            if tab.type in (Tab.TAB_CHAT, Tab.TAB_NOTEPAD, Tab.TAB_TOOL):
+                tab.cleanup()  # unload assigned data from memory
+
+            # tab.delete_refs()
+
+        except Exception as e:
+            print(f"Error unloading tab {pid}: {e}")
+            self.window.core.debug.log(e)
 
-        tab.cleanup() # unload assigned data from memory
         column_idx = tab.column_idx
         self.window.ui.layout.get_tabs_by_idx(column_idx).removeTab(tab.idx)
         del self.pids[pid]

pygpt_net/data/config/config.json

@@ -1,8 +1,8 @@
 {
   "__meta__": {
-    "version": "2.6.47",
-    "app.version": "2.6.47",
-    "updated_at": "2025-09-15T00:00:00"
+    "version": "2.6.49",
+    "app.version": "2.6.49",
+    "updated_at": "2025-09-16T00:00:00"
   },
   "access.audio.event.speech": false,
   "access.audio.event.speech.disabled": [],

pygpt_net/data/config/models.json

@@ -1,8 +1,8 @@
 {
     "__meta__": {
-        "version": "2.6.47",
-        "app.version": "2.6.47",
-        "updated_at": "2025-09-15T08:03:34"
+        "version": "2.6.49",
+        "app.version": "2.6.49",
+        "updated_at": "2025-09-16T08:03:34"
     },
     "items": {
         "SpeakLeash/bielik-11b-v2.3-instruct:Q4_K_M": {