pygpt-net 2.6.11__py3-none-any.whl → 2.6.12__py3-none-any.whl

pygpt_net/core/render/web/renderer.py

@@ -6,14 +6,16 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.18 01:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import json
 import os
 import re
+
 from datetime import datetime
 from typing import Optional, List, Any
+from time import monotonic
 
 from pygpt_net.core.render.base import BaseRenderer
 from pygpt_net.core.text.utils import has_unclosed_code_tag
@@ -57,7 +59,7 @@ class Renderer(BaseRenderer):
         self.body = Body(window)
         self.helpers = Helpers(window)
         self.parser = Parser(window)
-        self.pids = {}  # per node data
+        self.pids = {}
         self.prev_chunk_replace = False
         self.prev_chunk_newline = False
 
@@ -66,6 +68,9 @@ class Renderer(BaseRenderer):
         self._icon_sync = os.path.join(app_path, "data", "icons", "sync.svg")
         self._file_prefix = 'file:///' if self.window and self.window.core.platforms.is_windows() else 'file://'
 
+        self._thr = {}
+        self._throttle_interval = 0.01 # 10 ms delay
+
     def prepare(self):
         """
         Prepare renderer
@@ -104,8 +109,6 @@ class Renderer(BaseRenderer):
         if pid is None or pid not in self.pids:
             return
         self.pids[pid].loaded = True
-        node = self.get_output_node(meta)
-
         if self.pids[pid].html != "" and not self.pids[pid].use_buffer:
             self.clear_chunks_input(pid)
             self.clear_chunks_output(pid)
@@ -113,8 +116,6 @@ class Renderer(BaseRenderer):
             self.append(pid, self.pids[pid].html, flush=True)
             self.pids[pid].html = ""
 
-        node.setUpdatesEnabled(True)
-
     def get_pid(self, meta: CtxMeta):
         """
         Get PID for context meta
@@ -299,6 +300,9 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
+
+        self._throttle_emit(pid, force=True)
+        self._throttle_reset(pid)
         if self.window.controller.agent.legacy.enabled():
             if self.pids[pid].item is not None:
                 self.append_context_item(meta, self.pids[pid].item)
@@ -335,6 +339,7 @@ class Renderer(BaseRenderer):
         self.pids[pid].use_buffer = True
         self.pids[pid].html = ""
         prev_ctx = None
+        next_item = None
         total = len(items)
         for i, item in enumerate(items):
             self.update_names(meta, item)
@@ -349,14 +354,17 @@ class Renderer(BaseRenderer):
                 next_ctx=next_item
             )
             prev_ctx = item
-        self.pids[pid].use_buffer = False
 
+        prev_ctx = None
+        next_item = None
+        self.pids[pid].use_buffer = False
         if self.pids[pid].html != "":
             self.append(
                 pid,
                 self.pids[pid].html,
                 flush=True
             )
+        self.parser.reset()
 
     def append_input(
             self, meta: CtxMeta,
@@ -467,6 +475,8 @@ class Renderer(BaseRenderer):
         if not text_chunk:
             if begin:
                 pctx.clear()
+                self._throttle_emit(pid, force=True)
+                self._throttle_reset(pid)
             return
 
         name_header_str = self.get_name_header(ctx)
@@ -479,8 +489,10 @@ class Renderer(BaseRenderer):
                 debug = self.append_debug(ctx, pid, "stream")
                 if debug:
                     text_chunk = debug + text_chunk
-            pctx.clear()  # reset buffer
-            pctx.is_cmd = False  # reset command flag
+            self._throttle_emit(pid, force=True)
+            self._throttle_reset(pid)
+            pctx.clear()
+            pctx.is_cmd = False
             self.clear_chunks_output(pid)
             self.prev_chunk_replace = False
 
@@ -496,11 +508,12 @@ class Renderer(BaseRenderer):
         del buffer_to_parse
         is_code_block = html.endswith(self.ENDINGS_CODE)
         is_list = html.endswith(self.ENDINGS_LIST)
-        is_newline = ("\n" in text_chunk) or buffer.endswith("\n") or is_code_block
+        is_n = "\n" in text_chunk
+        is_newline = is_n or buffer.endswith("\n") or is_code_block
         force_replace = False
         if self.prev_chunk_newline:
             force_replace = True
-        if "\n" in text_chunk:
+        if is_n:
             self.prev_chunk_newline = True
         else:
             self.prev_chunk_newline = False
@@ -509,38 +522,26 @@ class Renderer(BaseRenderer):
         if is_newline or force_replace or is_list:
             replace = True
             if is_code_block:
-                # don't replace if it is a code block
-                if "\n" not in text_chunk:
-                    # if there is no newline in raw_chunk, then don't replace
+                if not is_n:
                     replace = False
 
         if not is_code_block:
-            text_chunk = text_chunk.replace("\n", "<br/>")
+            if is_n:
+                text_chunk = text_chunk.replace("\n", "<br/>")
         else:
-            if self.prev_chunk_replace and not has_unclosed_code_tag(text_chunk):
-                # if previous chunk was replaced and current is code block, then add \n to chunk
-                text_chunk = "".join(("\n", text_chunk))  # add newline to chunk
+            if self.prev_chunk_replace and (is_code_block and not has_unclosed_code_tag(text_chunk)):
+                text_chunk = "\n" + text_chunk
 
         self.prev_chunk_replace = replace
 
-        # hide loading spinner if it is the beginning of the text
         if begin:
             try:
                 self.get_output_node(meta).page().runJavaScript("hideLoading();")
             except Exception:
                 pass
 
-        # emit chunk to output node
-        try:
-            self.get_output_node(meta).page().bridge.chunk.emit(
-                name_header_str or "",
-                self.sanitize_html(html) if replace else "",
-                self.sanitize_html(text_chunk) if not replace else "",
-                bool(replace),
-                bool(is_code_block),
-            )
-        except Exception:
-            pass
+        self._throttle_queue(pid, name_header_str or "", html, text_chunk, replace, bool(is_code_block))
+        self._throttle_emit(pid, force=False)
 
     def next_chunk(
             self,
@@ -554,6 +555,8 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         """
         pid = self.get_or_create_pid(meta)
+        self._throttle_emit(pid, force=True)
+        self._throttle_reset(pid)
         self.pids[pid].item = ctx
         self.pids[pid].buffer = ""
         self.update_names(meta, ctx)
@@ -561,7 +564,8 @@ class Renderer(BaseRenderer):
         self.prev_chunk_newline = False
         try:
             self.get_output_node(meta).page().runJavaScript(
-                "nextStream();")
+                "nextStream();"
+            )
         except Exception:
             pass
 
@@ -635,7 +639,6 @@ class Renderer(BaseRenderer):
         to_append = self.pids[pid].live_buffer
         if has_unclosed_code_tag(self.pids[pid].live_buffer):
             to_append += "\n```"
-        print(to_append)
         try:
             self.get_output_node(meta).page().runJavaScript(
                 f"""replaceLive({self.to_json(
@@ -717,8 +720,9 @@ class Renderer(BaseRenderer):
         """
         if self.pids[pid].loaded and not self.pids[pid].use_buffer:
             self.clear_chunks(pid)
-            self.flush_output(pid, html)
-            self.pids[pid].html = ""
+            if html:
+                self.flush_output(pid, html)
+            self.pids[pid].clear()
         else:
             if not flush:
                 self.pids[pid].append_html(html)
@@ -911,6 +915,7 @@ class Renderer(BaseRenderer):
             node.reset_current_content()
         self.reset_names_by_pid(pid)
         self.prev_chunk_replace = False
+        self._throttle_reset(pid)
 
     def clear_input(self):
         """Clear input"""
@@ -977,6 +982,7 @@ class Renderer(BaseRenderer):
             self.get_output_node_by_pid(pid).page().runJavaScript(js)
         except Exception:
             pass
+        self._throttle_reset(pid)
 
     def clear_nodes(
             self,
@@ -1191,12 +1197,11 @@ class Renderer(BaseRenderer):
         """
         try:
             self.get_output_node_by_pid(pid).page().runJavaScript(
-                f"""if (typeof window.appendNode !== 'undefined') appendNode({self.to_json(
-                    self.sanitize_html(html)
-                )});"""
+                f"""if (typeof window.appendNode !== 'undefined') appendNode({self.to_json(self.sanitize_html(html))});"""
             )
         except Exception:
             pass
+        html = None
 
     def reload(self):
         """Reload output, called externally only on theme change to redraw content"""
@@ -1232,17 +1237,10 @@ class Renderer(BaseRenderer):
         pid = self.get_or_create_pid(meta)
         if pid is None:
             return
-        html = self.body.get_html(pid)
-        self.pids[pid].loaded = False
         node = self.get_output_node_by_pid(pid)
         if node is not None:
-            # hard reset
-            # old_view = node
-            # new_view = old_view.hard_reset()
-            # self.window.ui.nodes['output'][pid] = new_view
             node.resetPage()
-            node.setHtml(html, baseUrl="file://")
-        self.pids[pid].html = ""
+        self._throttle_reset(pid)
 
     def get_output_node(
             self,
@@ -1421,6 +1419,7 @@ class Renderer(BaseRenderer):
             self.clear_chunks(pid)
             self.clear_nodes(pid)
             self.pids[pid].html = ""
+            self._throttle_reset(pid)
 
     def scroll_to_bottom(self):
         """Scroll to bottom"""
@@ -1573,6 +1572,7 @@ class Renderer(BaseRenderer):
         :param ctx: context item
         :param pid: context PID
         :param title: debug title
+        :return: HTML debug info
         """
         if title is None:
             title = "debug"
@@ -1589,6 +1589,115 @@ class Renderer(BaseRenderer):
     def remove_pid(self, pid: int):
         """
         Remove PID from renderer
+
+        :param pid: context PID
         """
         if pid in self.pids:
-            del self.pids[pid]
+            del self.pids[pid]
+        self._thr.pop(pid, None)
+
+    def _throttle_get(self, pid: int) -> dict:
+        """
+        Return per-pid throttle state
+
+        :param pid: context PID
+        :return: throttle state dictionary
+        """
+        thr = self._thr.get(pid)
+        if thr is None:
+            thr = {"last": 0.0, "op": 0, "name": "", "replace_html": "", "append": [], "code": False}
+            self._thr[pid] = thr
+        return thr
+
+    def _throttle_reset(self, pid: Optional[int]):
+        """
+        Reset throttle state
+
+        :param pid: context PID
+        """
+        if pid is None:
+            return
+        thr = self._thr.get(pid)
+        if thr is None:
+            return
+        thr["op"] = 0
+        thr["name"] = ""
+        thr["replace_html"] = ""
+        thr["append"].clear()
+        thr["code"] = False
+
+    def _throttle_queue(
+            self,
+            pid: int,
+            name: str,
+            html: str,
+            text_chunk: str,
+            replace: bool,
+            is_code_block: bool
+    ):
+        """
+        Queue chunk for throttled emit
+
+        :param pid: context PID
+        :param name: name of the chunk
+        :param html: HTML content of the chunk
+        :param text_chunk: raw text chunk
+        :param replace: whether to replace the current content
+        :param is_code_block: whether the chunk is a code block
+        """
+        thr = self._throttle_get(pid)
+        if name:
+            thr["name"] = name
+        if replace:
+            thr["op"] = 1
+            thr["replace_html"] = html
+            thr["append"].clear()
+            thr["code"] = bool(is_code_block)
+        else:
+            if thr["op"] != 1:
+                thr["op"] = 2
+            thr["append"].append(text_chunk)
+            thr["code"] = bool(is_code_block)
+
+    def _throttle_emit(self, pid: int, force: bool = False):
+        """
+        Emit queued chunks if due
+
+        :param pid: context PID
+        :param force: force emit regardless of throttle interval
+        """
+        thr = self._throttle_get(pid)
+        now = monotonic()
+        if not force and (now - thr["last"] < self._throttle_interval):
+            return
+        if thr["op"] == 1:
+            try:
+                node = self.get_output_node_by_pid(pid)
+                if node is not None:
+                    node.page().bridge.chunk.emit(
+                        thr["name"],
+                        self.sanitize_html(thr["replace_html"]),
+                        "",
+                        True,
+                        bool(thr["code"]),
+                    )
+            except Exception:
+                pass
+            thr["last"] = now
+            self._throttle_reset(pid)
+        elif thr["op"] == 2 and thr["append"]:
+            append_str = "".join(thr["append"])
+            try:
+                node = self.get_output_node_by_pid(pid)
+                if node is not None:
+                    node.page().bridge.chunk.emit(
+                        thr["name"],
+                        "",
+                        self.sanitize_html(append_str),
+                        False,
+                        bool(thr["code"]),
+                    )
+            except Exception:
+                pass
+            thr["last"] = now
+            self._throttle_reset(pid)

pygpt_net/data/config/config.json

@@ -1,8 +1,8 @@
 {
   "__meta__": {
-    "version": "2.6.11",
-    "app.version": "2.6.11",
-    "updated_at": "2025-08-18T00:00:00"
+    "version": "2.6.12",
+    "app.version": "2.6.12",
+    "updated_at": "2025-08-19T00: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.11",
-        "app.version": "2.6.11",
-        "updated_at": "2025-08-18T23:07:35"
+        "version": "2.6.12",
+        "app.version": "2.6.12",
+        "updated_at": "2025-08-19T23:07:35"
     },
     "items": {
         "SpeakLeash/bielik-11b-v2.3-instruct:Q4_K_M": {

pygpt_net/item/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.15 23:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import copy
@@ -103,7 +103,7 @@ class CtxItem:
         if self.input is None:
             return None
         if self.hidden_input:
-            return self.input + "\n\n" + self.hidden_input
+            return "\n\n".join(self.input, self.hidden_input)
         return self.input
 
     @property
@@ -116,7 +116,7 @@ class CtxItem:
         if self.output is None:
             return None
         if self.hidden_output:
-            return self.output + "\n\n" + self.hidden_output
+            return "\n\n".join(self.output, self.hidden_output)
         return self.output
 
     def clear_reply(self):

pygpt_net/launcher.py

@@ -6,12 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 00:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
-import asyncio
-from qasync import QEventLoop
-
 import os
 import sys
 import argparse
@@ -123,8 +120,6 @@ class Launcher:
         QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts)
         self.app = QApplication(sys.argv)
         self.app.setAttribute(QtCore.Qt.AA_DontUseNativeMenuBar)
-        self.loop = QEventLoop(self.app)
-        asyncio.set_event_loop(self.loop)
         self.window = MainWindow(self.app, args=args)
         self.shortcut_filter = GlobalShortcutFilter(self.window)
 
@@ -295,6 +290,4 @@ class Launcher:
         # self.window.core.debug.mem("INIT")  # debug memory usage
         signal.signal(signal.SIGTERM, self.handle_signal)
         signal.signal(signal.SIGINT, self.handle_signal)
-        with self.loop:
-            self.loop.run_forever()
-        # sys.exit(self.app.exec())
+        sys.exit(self.app.exec())

pygpt_net/provider/gpt/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.12 19:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 from openai import OpenAI
@@ -63,6 +63,7 @@ class Gpt:
         self.vision = Vision(window)
         self.client = None
         self.locked = False
+        self.last_client_args = None  # last client args used, for debug purposes
 
     def get_client(
             self,
@@ -78,7 +79,15 @@ class Gpt:
         """
         # update client args by mode and model
         args = self.window.core.models.prepare_client_args(mode, model)
-        self.client = OpenAI(**args)
+        if self.client is None or self.last_client_args != args:
+            if self.client is not None:
+                try:
+                    self.client.close()  # close previous client if exists
+                except Exception as e:
+                    self.window.core.debug.log(e)
+                    print("Error closing previous GPT client:", e)
+            self.client = OpenAI(**args)
+        self.last_client_args = args
         return self.client
 
     def call(self, context: BridgeContext, extra: dict = None) -> bool:
@@ -308,8 +317,8 @@ class Gpt:
             return
         if self.client is not None:
             try:
-                self.client.close()
-                self.client = None
+                pass
+                # self.client.close()
             except Exception as e:
                 self.window.core.debug.log(e)
                 print("Error closing GPT client:", e)

pygpt_net/tools/code_interpreter/body.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.16 15:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import os
@@ -185,8 +185,7 @@ class Body:
         function highlightCode() {
             document.querySelectorAll('pre code').forEach(el => {
                 if (!el.classList.contains('hljs')) hljs.highlightElement(el);
-            });      
-            restoreCollapsedCode();   
+            });
         }
         function scrollToBottom() {
             getScrollPosition();  // store using bridge

pygpt_net/ui/main.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.18 01:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import os
@@ -115,7 +115,10 @@ class MainWindow(QMainWindow, QtStyleTools):
         if not render_debug:
             QLoggingCategory.setFilterRules("*.info=false")
         else:
-            os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = "--enable-logging --log-level=0"
+            if "QTWEBENGINE_CHROMIUM_FLAGS" in os.environ:
+                os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] += " --enable-logging --log-level=0"
+            else:
+                os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = "--enable-logging --log-level=0"
 
         # OpenGL disable
         if self.core.config.get("render.open_gl") is False:

pygpt_net/ui/widget/textarea/html.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.08 21:00:00                  #
+# Updated Date: 2025.08.19 07:00:00                  #
 # ================================================== #
 
 import re
@@ -207,12 +207,7 @@ class HtmlOutput(QWebEngineView):
 
         :param success: True if loaded successfully
         """
-        if success:
-            event = RenderEvent(RenderEvent.ON_PAGE_LOAD, {
-                "meta": self.meta,
-                "tab": self.tab,
-            })
-            self.window.dispatch(event)
+        pass
 
     def get_selected_text(self) -> str:
         """