pygpt-net 2.6.1__py3-none-any.whl → 2.6.6__py3-none-any.whl

pygpt_net/controller/chat/response.py

@@ -171,8 +171,9 @@ class Response:
             if output and has_unclosed_code_tag(output):
                 ctx.output += "\n```"
             ctx.msg_id = None
-            self.window.core.ctx.add(ctx)  # store context to prevent current output from being lost
-            self.window.controller.ctx.prepare_name(ctx)  # summarize if not yet
+            if ctx.id is None:
+                self.window.core.ctx.add(ctx)  # store context to prevent current output from being lost
+                self.window.controller.ctx.prepare_name(ctx)  # summarize if not yet
 
             # finish render
             self.window.dispatch(AppEvent(AppEvent.CTX_END))  # app event
@@ -228,7 +229,8 @@ class Response:
         }
         event = RenderEvent(RenderEvent.INPUT_APPEND, data)
         self.window.dispatch(event)
-        self.window.core.ctx.add(ctx)
+        if ctx.id is None:
+            self.window.core.ctx.add(ctx)
         self.window.controller.ctx.update(
             reload=True,
             all=False,

pygpt_net/controller/chat/stream.py

@@ -6,11 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.11 14:00:00                  #
+# Updated Date: 2025.08.16 00:00:00                  #
 # ================================================== #
 
 import base64
-from typing import Optional
+import gc
+import io
+from typing import Optional, Literal
 
 from PySide6.QtCore import QObject, Signal, Slot, QRunnable
 
@@ -20,6 +22,32 @@ from pygpt_net.core.types import MODE_ASSISTANT
 from pygpt_net.core.text.utils import has_unclosed_code_tag
 from pygpt_net.item.ctx import CtxItem
 
+EventType = Literal[
+    "response.completed",
+    "response.output_text.delta",
+    "response.output_item.added",
+    "response.function_call_arguments.delta",
+    "response.function_call_arguments.done",
+    "response.output_text.annotation.added",
+    "response.reasoning_summary_text.delta",
+    "response.output_item.done",
+    "response.code_interpreter_call_code.delta",
+    "response.code_interpreter_call_code.done",
+    "response.image_generation_call.partial_image",
+    "response.created",
+    "response.done",
+    "response.failed",
+    "error",
+]
+ChunkType = Literal[
+    "api_chat",
+    "api_chat_responses",
+    "api_completion",
+    "langchain_chat",
+    "llama_chat",
+    "raw",
+]
+
 class WorkerSignals(QObject):
     """
     Defines the signals available from a running worker thread.
@@ -54,15 +82,15 @@ class StreamWorker(QRunnable):
         output_tokens = 0
         begin = True
         error = None
-        fn_args_buffers = {}
-        citations = []
+        fn_args_buffers: dict[str, io.StringIO] = {}
+        citations: Optional[list] = []
         files = []
         img_path = core.image.gen_unique_path(ctx)
         is_image = False
         is_code = False
         force_func_call = False
         stopped = False
-        chunk_type = "raw"
+        chunk_type: ChunkType = "raw"
         generator = ctx.stream
         ctx.stream = None
 
@@ -77,6 +105,21 @@ class StreamWorker(QRunnable):
             if generator is not None:
                 for chunk in generator:
                     if ctrl.kernel.stopped():
+                        if hasattr(generator, 'close'):
+                            try:
+                                generator.close()
+                            except Exception:
+                                pass
+                        elif hasattr(generator, 'cancel'):
+                            try:
+                                generator.cancel()
+                            except Exception:
+                                pass
+                        elif hasattr(generator, 'stop'):
+                            try:
+                                generator.stop()
+                            except Exception:
+                                pass
                         ctx.msg_id = None
                         stopped = True
                         break
@@ -86,12 +129,12 @@ class StreamWorker(QRunnable):
                         stopped = True
                         break
 
-                    etype = None
+                    etype: Optional[EventType] = None
                     response = None
 
                     if ctx.use_responses_api:
                         if hasattr(chunk, 'type'):
-                            etype = chunk.type
+                            etype = chunk.type  # type: ignore[assignment]
                             chunk_type = "api_chat_responses"
                         else:
                             continue
@@ -113,7 +156,6 @@ class StreamWorker(QRunnable):
                         else:
                             chunk_type = "raw"
 
-                    # OpenAI chat completion
                     if chunk_type == "api_chat":
                         citations = None
                         delta = chunk.choices[0].delta
@@ -143,7 +185,6 @@ class StreamWorker(QRunnable):
                                 if getattr(tool_chunk.function, "arguments", None):
                                     tool_call["function"]["arguments"] += tool_chunk.function.arguments
 
-                    # OpenAI Responses API
                     elif chunk_type == "api_chat_responses":
                         if etype == "response.completed":
                             for item in chunk.response.output:
@@ -182,7 +223,6 @@ class StreamWorker(QRunnable):
                         elif etype == "response.output_text.delta":
                             response = chunk.delta
 
-                        # function_call
                         elif etype == "response.output_item.added" and chunk.item.type == "function_call":
                             tool_calls.append({
                                 "id": chunk.item.id,
@@ -190,18 +230,23 @@ class StreamWorker(QRunnable):
                                 "type": "function",
                                 "function": {"name": chunk.item.name, "arguments": ""}
                             })
-                            fn_args_buffers[chunk.item.id] = ""
+                            fn_args_buffers[chunk.item.id] = io.StringIO()
                         elif etype == "response.function_call_arguments.delta":
-                            fn_args_buffers[chunk.item_id] += chunk.delta
+                            buf = fn_args_buffers.get(chunk.item_id)
+                            if buf is not None:
+                                buf.write(chunk.delta)
                         elif etype == "response.function_call_arguments.done":
                             buf = fn_args_buffers.pop(chunk.item_id, None)
                             if buf is not None:
+                                try:
+                                    args_val = buf.getvalue()
+                                finally:
+                                    buf.close()
                                 for tc in tool_calls:
                                     if tc["id"] == chunk.item_id:
-                                        tc["function"]["arguments"] = buf
+                                        tc["function"]["arguments"] = args_val
                                         break
 
-                        # annotations
                         elif etype == "response.output_text.annotation.added":
                             ann = chunk.annotation
                             if ann['type'] == "url_citation":
@@ -216,7 +261,6 @@ class StreamWorker(QRunnable):
                                     "file_id": ann['file_id'],
                                 })
 
-                        # computer use
                         elif etype == "response.reasoning_summary_text.delta":
                             response = chunk.delta
 
@@ -225,7 +269,6 @@ class StreamWorker(QRunnable):
                             if has_calls:
                                 force_func_call = True
 
-                        # code interpreter
                         elif etype == "response.code_interpreter_call_code.delta":
                             if not is_code:
                                 response = "\n\n**Code interpreter**\n```python\n" + chunk.delta
@@ -235,36 +278,30 @@ class StreamWorker(QRunnable):
                         elif etype == "response.code_interpreter_call_code.done":
                             response = "\n\n```\n-----------\n"
 
-                        # image gen
                         elif etype == "response.image_generation_call.partial_image":
                             image_base64 = chunk.partial_image_b64
                             image_bytes = base64.b64decode(image_base64)
-                            # prosty i bezpieczny overwrite (jak w oryginale)
                             with open(img_path, "wb") as f:
                                 f.write(image_bytes)
+                            del image_bytes
                             is_image = True
 
-                        # response ID
                         elif etype == "response.created":
                             ctx.msg_id = str(chunk.response.id)
                             core.ctx.update_item(ctx)
 
-                        # end/error etype – nic nie robimy
                         elif etype in {"response.done", "response.failed", "error"}:
                             pass
 
-                    # OpenAI completion
                     elif chunk_type == "api_completion":
                         choice0 = chunk.choices[0]
                         if choice0.text is not None:
                             response = choice0.text
 
-                    # langchain chat
                     elif chunk_type == "langchain_chat":
                         if chunk.content is not None:
                             response = str(chunk.content)
 
-                    # llama chat
                     elif chunk_type == "llama_chat":
                         if chunk.delta is not None:
                             response = str(chunk.delta)
@@ -288,7 +325,6 @@ class StreamWorker(QRunnable):
                                     tool_calls.clear()
                                     tool_calls.append(tool_call)
 
-                    # raw text (llama-index / langchain completion)
                     else:
                         if chunk is not None:
                             response = str(chunk)
@@ -313,13 +349,11 @@ class StreamWorker(QRunnable):
 
                     chunk = None
 
-                # tool calls
                 if tool_calls:
                     ctx.force_call = force_func_call
                     core.debug.info("[chat] Tool calls found, unpacking...")
                     core.command.unpack_tool_calls_chunks(ctx, tool_calls)
 
-                # image
                 if is_image:
                     core.debug.info("[chat] Image generation call found")
                     ctx.images = [img_path]
@@ -358,11 +392,17 @@ class StreamWorker(QRunnable):
 
             emit_end(ctx)
 
+            for _buf in fn_args_buffers.values():
+                try:
+                    _buf.close()
+                except Exception:
+                    pass
             fn_args_buffers.clear()
             files.clear()
             tool_calls.clear()
-            if citations is not None:
+            if citations is not None and citations is not ctx.urls:
                 citations.clear()
+            citations = None
 
             self.cleanup()
 
@@ -407,6 +447,14 @@ class Stream:
     ):
         """
         Asynchronous append of stream worker to the thread.
+
+        :param ctx: Context item
+        :param mode: Mode of operation (e.g., MODE_ASSISTANT)
+        :param is_response: Whether this is a response stream
+        :param reply: Reply identifier
+        :param internal: Whether this is an internal stream
+        :param context: Optional BridgeContext for additional context
+        :param extra: Additional data to pass to the stream
         """
         self.ctx = ctx
         self.mode = mode
@@ -430,6 +478,8 @@ class Stream:
     def handleEnd(self, ctx: CtxItem):
         """
         Slot for handling end of stream
+
+        :param ctx: Context item
         """
         self.window.controller.ui.update_tokens()
 
@@ -457,9 +507,19 @@ class Stream:
         self.worker = None
 
     def handleEvent(self, event):
+        """
+        Slot for handling stream events
+
+        :param event: RenderEvent
+        """
         self.window.dispatch(event)
 
     def handleError(self, error):
+        """
+        Slot for handling stream errors
+
+        :param error: Exception or error message
+        """
         self.window.core.debug.log(error)
         if self.is_response:
             if not isinstance(self.extra, dict):
@@ -475,4 +535,9 @@ class Stream:
             )
 
     def log(self, data: object):
+        """
+        Log data to the debug console
+
+        :param data: object to log
+        """
         self.window.core.debug.info(data)

pygpt_net/controller/config/config.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.06.30 02:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 from typing import Any, Dict, List
@@ -40,6 +40,24 @@ class Config:
         self.slider = Slider(window)
         self.textarea = Textarea(window)
 
+        self._apply_map = {
+            'text': self.input.apply,
+            'textarea': self.textarea.apply,
+            'bool': self.checkbox.apply,
+            'bool_list': self.checkbox_list.apply,
+            'dict': self.dictionary.apply,
+            'combo': self.combo.apply,
+            'cmd': self.cmd.apply,
+        }
+        self._get_map = {
+            'text': self.input.get_value,
+            'textarea': self.textarea.get_value,
+            'bool': self.checkbox.get_value,
+            'bool_list': self.checkbox_list.get_value,
+            'dict': self.dictionary.get_value,
+            'cmd': self.cmd.get_value,
+        }
+
     def load_options(
             self,
             parent_id: str,
@@ -51,8 +69,7 @@ class Config:
         :param parent_id: Parent ID
         :param options: Options dict
         """
-        for key in options:
-            option = options[key]
+        for key, option in options.items():
             self.apply(parent_id, key, option)
 
     def apply(
@@ -68,25 +85,16 @@ class Config:
         :param key: Option key
         :param option: Option dict
         """
-        if option['type'] == 'int' or option['type'] == 'float':
-            if 'slider' in option and option['slider']:
+        t = option['type']
+        if t in ('int', 'float'):
+            if option.get('slider'):
                 self.slider.apply(parent_id, key, option)
             else:
                 self.input.apply(parent_id, key, option)
-        elif option['type'] == 'text':
-            self.input.apply(parent_id, key, option)
-        elif option['type'] == 'textarea':
-            self.textarea.apply(parent_id, key, option)
-        elif option['type'] == 'bool':
-            self.checkbox.apply(parent_id, key, option)
-        elif option['type'] == 'bool_list':
-            self.checkbox_list.apply(parent_id, key, option)
-        elif option['type'] == 'dict':
-            self.dictionary.apply(parent_id, key, option)
-        elif option['type'] == 'combo':
-            self.combo.apply(parent_id, key, option)
-        elif option['type'] == 'cmd':
-            self.cmd.apply(parent_id, key, option)
+            return
+        func = self._apply_map.get(t)
+        if func:
+            func(parent_id, key, option)
 
     def apply_value(
             self,
@@ -122,25 +130,16 @@ class Config:
         :param idx: return selected idx, not the value
         :return: Option value
         """
-        if option['type'] == 'int' or option['type'] == 'float':
-            if 'slider' in option and option['slider']:
+        t = option['type']
+        if t in ('int', 'float'):
+            if option.get('slider'):
                 return self.slider.get_value(parent_id, key, option)
-            else:
-                return self.input.get_value(parent_id, key, option)
-        elif option['type'] == 'text':
             return self.input.get_value(parent_id, key, option)
-        elif option['type'] == 'textarea':
-            return self.textarea.get_value(parent_id, key, option)
-        elif option['type'] == 'bool':
-            return self.checkbox.get_value(parent_id, key, option)
-        elif option['type'] == 'bool_list':
-            return self.checkbox_list.get_value(parent_id, key, option)
-        elif option['type'] == 'dict':
-            return self.dictionary.get_value(parent_id, key, option)
-        elif option['type'] == 'combo':
+        if t == 'combo':
             return self.combo.get_value(parent_id, key, option, idx)
-        elif option['type'] == 'cmd':
-            return self.cmd.get_value(parent_id, key, option)
+        func = self._get_map.get(t)
+        if func:
+            return func(parent_id, key, option)
 
     def update_list(
             self,
@@ -159,13 +158,11 @@ class Config:
         """
         if "type" not in option:
             return
-        if option['type'] == 'combo':
-            as_dict = {}
-            for item in items:
-                for k, v in item.items():
-                    as_dict[k] = v
+        t = option['type']
+        if t == 'combo':
+            as_dict = {k: v for d in items for k, v in d.items()}
             self.update_combo(parent_id, key, as_dict)
-        elif option['type'] == 'bool_list':
+        elif t == 'bool_list':
             self.update_bool_list(parent_id, key, items)
 
     def update_combo(
@@ -196,4 +193,4 @@ class Config:
         :param key: Option key
         :param items: Items dict
         """
-        self.checkbox_list.update_list(parent_id, key, items)
+        self.checkbox_list.update_list(parent_id, key, items)

pygpt_net/controller/config/field/checkbox.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.06.29 18:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 from typing import Any, Dict
@@ -26,7 +26,7 @@ class Checkbox:
             parent_id: str,
             key: str,
             option: Dict[str, Any]
-    ):
+    ) -> None:
         """
         Apply value to checkbox
 
@@ -39,17 +39,19 @@ class Checkbox:
         value = option["value"]
         if value is None:
             value = False
-        if key in self.window.ui.config[parent_id]:
-            self.window.ui.config[parent_id][key].box.setChecked(bool(value))
+        cfg_parent = self.window.ui.config[parent_id]
+        row = cfg_parent.get(key)
+        if row is not None:
+            row.box.setChecked(bool(value))
 
     def on_update(
             self,
             parent_id: str,
             key: str,
-            option: dict,
+            option: Dict[str, Any],
             value: Any,
             hooks: bool = True
-    ):
+    ) -> None:
         """
         Event: on update checkbox value
 
@@ -59,11 +61,11 @@ class Checkbox:
         :param value: Option value
         :param hooks: Run hooks
         """
-        # on update hooks
         if hooks:
-            hook_name = "update.{}.{}".format(parent_id, key)
-            if self.window.ui.has_hook(hook_name):
-                hook = self.window.ui.get_hook(hook_name)
+            ui = self.window.ui
+            hook_name = f"update.{parent_id}.{key}"
+            if ui.has_hook(hook_name):
+                hook = ui.get_hook(hook_name)
                 try:
                     hook(key, value, 'checkbox')
                 except Exception as e:
@@ -83,6 +85,8 @@ class Checkbox:
         :param option: Option data dict
         :return: Option value
         """
-        if key not in self.window.ui.config[parent_id]:
+        cfg_parent = self.window.ui.config[parent_id]
+        row = cfg_parent.get(key)
+        if row is None:
             return False
-        return self.window.ui.config[parent_id][key].box.isChecked()
+        return row.box.isChecked()

pygpt_net/controller/config/field/checkbox_list.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.06.30 02:00:00                  #
+# Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
 from typing import Any, Dict, List
@@ -37,19 +37,24 @@ class CheckboxList:
         if "value" not in option:
             return
         value = option["value"]
-        exploded_list = value.split(",") if isinstance(value, str) else []
-        if key not in self.window.ui.config[parent_id]:
-            self.window.ui.config[parent_id][key] = {}
-        for item in self.window.ui.config[parent_id][key].boxes:
-            if self.window.ui.config[parent_id][key].boxes[item] is not None:
-                self.window.ui.config[parent_id][key].boxes[item].setChecked(False)
-        for item in exploded_list:
-            item = item.strip()
-            if item not in self.window.ui.config[parent_id][key].boxes:
-                continue
-            if self.window.ui.config[parent_id][key].boxes[item] is None:
+        selection = {s.strip() for s in value.split(",")} if isinstance(value, str) else set()
+        selection.discard("")
+
+        ui = self.window.ui
+        cfg_parent = ui.config.get(parent_id)
+        if not cfg_parent:
+            return
+        entry = cfg_parent.get(key)
+        if entry is None or not hasattr(entry, "boxes"):
+            return
+        boxes = entry.boxes
+
+        for name, cb in boxes.items():
+            if cb is None:
                 continue
-            self.window.ui.config[parent_id][key].boxes[item].setChecked(True)
+            desired = name in selection
+            if cb.isChecked() != desired:
+                cb.setChecked(desired)
 
     def on_update(
             self,
@@ -70,15 +75,16 @@ class CheckboxList:
         :param subkey: Subkey for specific checkbox
         :param hooks: Run hooks
         """
-        # on update hooks
         if hooks:
-            hook_name = "update.{}.{}".format(parent_id, key)
-            if self.window.ui.has_hook(hook_name):
-                hook = self.window.ui.get_hook(hook_name)
-                try:
-                    hook(key, value, 'bool_list')
-                except Exception as e:
-                    self.window.core.debug.log(e)
+            ui = self.window.ui
+            hook_name = f"update.{parent_id}.{key}"
+            if ui.has_hook(hook_name):
+                hook = ui.get_hook(hook_name)
+                if hook:
+                    try:
+                        hook(key, value, 'bool_list')
+                    except Exception as e:
+                        self.window.core.debug.log(e)
 
     def get_value(
             self,
@@ -94,16 +100,15 @@ class CheckboxList:
         :param option: Option data dict
         :return: Option value
         """
-        if key not in self.window.ui.config[parent_id]:
+        ui = self.window.ui
+        cfg_parent = ui.config.get(parent_id)
+        if not cfg_parent:
             return ""
-        imploded_list = []
-        for item in self.window.ui.config[parent_id][key].boxes:
-            if self.window.ui.config[parent_id][key].boxes[item] is None:
-                continue
-            if self.window.ui.config[parent_id][key].boxes[item].isChecked():
-                imploded_list.append(item)
-        return ",".join(imploded_list)
-
+        entry = cfg_parent.get(key)
+        if entry is None or not hasattr(entry, "boxes"):
+            return ""
+        boxes = entry.boxes
+        return ",".join(name for name, cb in boxes.items() if cb is not None and cb.isChecked())
 
     def update_list(
             self,
@@ -118,4 +123,4 @@ class CheckboxList:
         :param key: Option key
         :param items: Items dict
         """
-        self.window.ui.config[parent_id][key].update_boxes_list(items)
+        self.window.ui.config[parent_id][key].update_boxes_list(items)