pygpt-net 2.6.34__py3-none-any.whl → 2.6.35__py3-none-any.whl

pygpt_net/CHANGELOG.txt

@@ -1,3 +1,10 @@
+2.6.35 (2025-09-04)
+
+- Improved responsiveness in chat streaming.
+- Added zoom, fit, and auto-scroll on crop in Painter.
+- Added a scroll-up button in the chat window.
+- Optimized memory usage.
+
 2.6.34 (2025-09-03)
 
 - Added auto-resizing for input.

pygpt_net/__init__.py

@@ -6,15 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.03 00:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 __author__ = "Marcin Szczygliński"
 __copyright__ = "Copyright 2025, Marcin Szczygliński"
 __credits__ = ["Marcin Szczygliński"]
 __license__ = "MIT"
-__version__ = "2.6.34"
-__build__ = "2025-09-03"
+__version__ = "2.6.35"
+__build__ = "2025-09-04"
 __maintainer__ = "Marcin Szczygliński"
 __github__ = "https://github.com/szczyglis-dev/py-gpt"
 __report__ = "https://github.com/szczyglis-dev/py-gpt/issues"

pygpt_net/controller/chat/common.py

@@ -292,8 +292,6 @@ class Common:
         }))  # stop audio input
         controller.kernel.halt = True
         dispatch(RenderEvent(RenderEvent.TOOL_END))  # show waiting
-
-        core.api.openai.stop()
         self.unlock_input()
 
         controller.chat.input.generating = False
@@ -311,6 +309,14 @@ class Common:
         if not exit:
             dispatch(AppEvent(AppEvent.INPUT_STOPPED))  # app event
 
+        self.stop_client()  # stop clients
+
+    def stop_client(self):
+        """Stop all clients"""
+        return # TODO: make it work without connection error after close
+        self.window.core.api.openai.safe_close()
+        self.window.core.api.google.safe_close()
+
     def check_api_key(
             self,
             mode: str,

pygpt_net/controller/chat/handler/stream_worker.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.28 20:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 import base64
@@ -14,6 +14,7 @@ import io
 import json
 from dataclasses import dataclass, field
 from typing import Optional, Literal, Any
+from enum import Enum
 
 from PySide6.QtCore import QObject, Signal, Slot, QRunnable
 
@@ -40,16 +41,18 @@ EventType = Literal[
     "error",
 ]
 
-# Chunks
-ChunkType = Literal[
-    "api_chat",
-    "api_chat_responses",
-    "api_completion",
-    "langchain_chat",
-    "llama_chat",
-    "google",
-    "raw",
-]
+
+class ChunkType(str, Enum):
+    """
+    Enum for chunk type classification.
+    """
+    API_CHAT = "api_chat"
+    API_CHAT_RESPONSES = "api_chat_responses"
+    API_COMPLETION = "api_completion"
+    LANGCHAIN_CHAT = "langchain_chat"
+    LLAMA_CHAT = "llama_chat"
+    GOOGLE = "google"
+    RAW = "raw"
 
 
 class WorkerSignals(QObject):
@@ -64,10 +67,10 @@ class WorkerSignals(QObject):
     eventReady = Signal(object)
 
 
-@dataclass
+@dataclass(slots=True)
 class WorkerState:
     """Holds mutable state for the streaming loop."""
-    output_parts: list[str] = field(default_factory=list)
+    out: Optional[io.StringIO] = None
     output_tokens: int = 0
     begin: bool = True
     error: Optional[Exception] = None
@@ -81,7 +84,7 @@ class WorkerState:
     is_code: bool = False
     force_func_call: bool = False
     stopped: bool = False
-    chunk_type: ChunkType = "raw"
+    chunk_type: ChunkType = ChunkType.RAW
     generator: Any = None
     usage_vendor: Optional[str] = None
     usage_payload: dict = field(default_factory=dict)
@@ -90,6 +93,8 @@ class WorkerState:
 
 
 class StreamWorker(QRunnable):
+    __slots__ = ("signals", "ctx", "window", "stream")
+
     def __init__(self, ctx: CtxItem, window, parent=None):
         super().__init__()
         self.signals = WorkerSignals()
@@ -134,7 +139,7 @@ class StreamWorker(QRunnable):
                     if ctx.use_responses_api:
                         if hasattr(chunk, 'type'):
                             etype = chunk.type  # type: ignore[assignment]
-                            state.chunk_type = "api_chat_responses"
+                            state.chunk_type = ChunkType.API_CHAT_RESPONSES
                         else:
                             continue
                     else:
@@ -199,23 +204,21 @@ class StreamWorker(QRunnable):
         :param chunk: The chunk object from the stream
         :return: Detected ChunkType
         """
-        if (hasattr(chunk, 'choices')
-                and chunk.choices
-                and hasattr(chunk.choices[0], 'delta')
-                and chunk.choices[0].delta is not None):
-            return "api_chat"
-        if (hasattr(chunk, 'choices')
-                and chunk.choices
-                and hasattr(chunk.choices[0], 'text')
-                and chunk.choices[0].text is not None):
-            return "api_completion"
-        if hasattr(chunk, 'content') and chunk.content is not None:
-            return "langchain_chat"
-        if hasattr(chunk, 'delta') and chunk.delta is not None:
-            return "llama_chat"
-        if hasattr(chunk, "candidates"):  # Google python-genai chunk
-            return "google"
-        return "raw"
+        choices = getattr(chunk, 'choices', None)
+        if choices:
+            choice0 = choices[0] if len(choices) > 0 else None
+            if choice0 is not None and hasattr(choice0, 'delta') and choice0.delta is not None:
+                return ChunkType.API_CHAT
+            if choice0 is not None and hasattr(choice0, 'text') and choice0.text is not None:
+                return ChunkType.API_COMPLETION
+
+        if hasattr(chunk, 'content') and getattr(chunk, 'content') is not None:
+            return ChunkType.LANGCHAIN_CHAT
+        if hasattr(chunk, 'delta') and getattr(chunk, 'delta') is not None:
+            return ChunkType.LLAMA_CHAT
+        if hasattr(chunk, "candidates"):
+            return ChunkType.GOOGLE
+        return ChunkType.RAW
 
     def _append_response(
             self,
@@ -236,7 +239,10 @@ class StreamWorker(QRunnable):
         """
         if state.begin and response == "":
             return
-        state.output_parts.append(response)
+        # Use a single expandable buffer to avoid per-chunk list allocations
+        if state.out is None:
+            state.out = io.StringIO()
+        state.out.write(response)
         state.output_tokens += 1
         emit_event(
             RenderEvent(
@@ -307,9 +313,14 @@ class StreamWorker(QRunnable):
         :param state: WorkerState
         :param emit_end: Function to emit end signal
         """
-        # Build final output
-        output = "".join(state.output_parts)
-        state.output_parts.clear()
+        # Build final output from the incremental buffer
+        output = state.out.getvalue() if state.out is not None else ""
+        if state.out is not None:
+            try:
+                state.out.close()
+            except Exception:
+                pass
+            state.out = None
 
         if has_unclosed_code_tag(output):
             output += "\n```"
@@ -336,6 +347,7 @@ class StreamWorker(QRunnable):
 
         self.stream = None
         ctx.output = output
+        output = None  # free ref
 
         # Tokens usage
         if state.usage_payload:
@@ -418,17 +430,17 @@ class StreamWorker(QRunnable):
         :return: Response delta string or None
         """
         t = state.chunk_type
-        if t == "api_chat":
+        if t == ChunkType.API_CHAT:
             return self._process_api_chat(ctx, state, chunk)
-        if t == "api_chat_responses":
+        if t == ChunkType.API_CHAT_RESPONSES:
             return self._process_api_chat_responses(ctx, core, state, chunk, etype)
-        if t == "api_completion":
+        if t == ChunkType.API_COMPLETION:
             return self._process_api_completion(chunk)
-        if t == "langchain_chat":
+        if t == ChunkType.LANGCHAIN_CHAT:
             return self._process_langchain_chat(chunk)
-        if t == "llama_chat":
+        if t == ChunkType.LLAMA_CHAT:
             return self._process_llama_chat(state, chunk)
-        if t == "google":
+        if t == ChunkType.GOOGLE:
             return self._process_google_chunk(ctx, core, state, chunk)
         # raw fallback
         return self._process_raw(chunk)
@@ -1109,7 +1121,7 @@ class StreamWorker(QRunnable):
             except Exception:
                 pass
 
-        # Bind to ctx on first discovery for compatibility with other parts of the app
+        # Bind to ctx on first discovery
         if state.citations and (ctx.urls is None or not ctx.urls):
             ctx.urls = list(state.citations)
 

pygpt_net/controller/painter/common.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.02 20:00:00                  #
+# Updated Date: 2025.09.02 15:00:00                  #
 # ================================================== #
 
 from typing import Tuple, Optional, Dict, List
@@ -208,6 +208,18 @@ class Common:
             self.window.ui.nodes['painter.select.brush.size'].findText(str(size))
         )
 
+    def restore_zoom(self):
+        """Restore zoom from config"""
+        if self.window.core.config.has('painter.zoom'):
+            zoom = int(self.window.core.config.get('painter.zoom', 100))
+            self.window.ui.painter.set_zoom_percent(zoom)
+
+    def save_zoom(self):
+        """Save zoom to config"""
+        zoom = self.window.ui.painter.get_zoom_percent()
+        self.window.core.config.set('painter.zoom', zoom)
+        self.window.core.config.save()
+
     def get_colors(self) -> Dict[str, QColor]:
         """
         Get colors dict

pygpt_net/controller/painter/painter.py

@@ -1,4 +1,13 @@
-# controller/painter/painter.py
+#!/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.02 15:00:00                  #
+# ================================================== #
 
 import os
 
@@ -51,7 +60,7 @@ class Painter:
         if not hasattr(self.window.ui, 'painter'):
             return
         path = os.path.join(self.common.get_capture_dir(), '_current.png')
-        self.window.ui.painter.image.save(path)
+        self.window.ui.painter.save_base(path, include_drawing=True)
 
     def save_all(self):
         """Save all (on exit)"""

pygpt_net/core/bridge/bridge.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.30 06:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 import time
@@ -130,7 +130,6 @@ class Bridge:
                 self.window.core.debug.debug(str(debug))
 
         self.apply_rate_limit()  # apply RPM limit
-        self.last_context = weakref.ref(context)  # store last context for call (debug)
 
         if extra is None:
             extra = {}
@@ -202,9 +201,6 @@ class Bridge:
                 debug = {k: str(v) for k, v in context.to_dict().items()}
                 self.window.core.debug.debug(str(debug))
 
-        # --- DEBUG ONLY ---
-        self.last_context_quick = weakref.ref(context)  # store last context for quick call (debug)
-
         if context.model is not None:
             # check if model is supported by OpenAI API, if not then try to use llama-index or langchain call
             if not context.model.is_supported(MODE_CHAT):

pygpt_net/core/bridge/context.py

@@ -6,30 +6,101 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.23 15:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 import json
-from typing import Dict, Any
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
 
 from pygpt_net.item.ctx import CtxItem
 from pygpt_net.item.model import ModelItem
 
+
+@dataclass(slots=True)
+class MultimodalContext:
+    """
+    Multimodal context
+    """
+    is_audio_input: bool = False
+    is_audio_output: bool = False
+    audio_data: Optional[Any] = None
+    audio_format: str = "wav"
+
+    def __init__(self, **kwargs):
+        """
+        Multimodal context
+
+        :param kwargs: keyword arguments
+        """
+        # kwargs-based initialization
+        self.is_audio_input = kwargs.get("is_audio_input", False)
+        self.is_audio_output = kwargs.get("is_audio_output", False)
+        self.audio_data = kwargs.get("audio_data", None)
+        self.audio_format = kwargs.get("audio_format", "wav")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Return as dictionary
+
+        :return: dictionary
+        """
+        data = {
+            "is_audio_input": self.is_audio_input,
+            "is_audio_output": self.is_audio_output,
+            "audio_format": self.audio_format,
+        }
+        # sort by keys
+        return dict(sorted(data.items(), key=lambda item: item[0]))
+
+
+@dataclass(slots=True)
 class BridgeContext:
+    """
+    Bridge context
+    """
+    assistant_id: str = ""
+    attachments: dict = field(default_factory=dict)
+    ctx: Optional[CtxItem] = None
+    external_functions: list = field(default_factory=list)
+    file_ids: list = field(default_factory=list)
+    force: bool = False  # Force mode flag
+    force_sync: bool = False  # Force sync flag
+    history: list = field(default_factory=list)
+    idx: Optional[Any] = None
+    idx_mode: str = "chat"
+    is_expert_call: bool = False  # Expert call flag
+    max_tokens: int = 0
+    mode: Optional[Any] = None
+    model: Optional[ModelItem] = None  # model instance, not model name
+    multimodal_ctx: MultimodalContext = field(default_factory=lambda: MultimodalContext())  # AudioContext
+    parent_mode: Optional[Any] = None  # real mode (global)
+    preset: Optional[Any] = None  # PresetItem
+    prompt: str = ""
+    reply_context: Optional[Any] = None  # ReplyContext
+    request: bool = False  # Use normal request instead of quick call
+    stream: bool = False
+    system_prompt: str = ""
+    system_prompt_raw: str = ""  # without plugins addons
+    temperature: float = 1.0
+    thread_id: str = ""
+    tools_outputs: list = field(default_factory=list)
+
     def __init__(self, **kwargs):
         """
         Bridge context
 
         :param kwargs: keyword arguments
         """
+        # Assign with defaults
         self.assistant_id = kwargs.get("assistant_id", "")
-        self.attachments = kwargs.get("attachments", [])
+        self.attachments = dict(kwargs.get("attachments", []))
         self.ctx = kwargs.get("ctx", None)
-        self.external_functions = kwargs.get("external_functions", [])
-        self.file_ids = kwargs.get("file_ids", [])
+        self.external_functions = list(kwargs.get("external_functions", []))
+        self.file_ids = list(kwargs.get("file_ids", []))
         self.force = kwargs.get("force", False)  # Force mode flag
         self.force_sync = kwargs.get("force_sync", False)  # Force sync flag
-        self.history = kwargs.get("history", [])
+        self.history = list(kwargs.get("history", []))
         self.idx = kwargs.get("idx", None)
         self.idx_mode = kwargs.get("idx_mode", "chat")
         self.is_expert_call = kwargs.get("is_expert_call", False)  # Expert call flag
@@ -40,14 +111,14 @@ class BridgeContext:
         self.parent_mode = kwargs.get("parent_mode", None)  # real mode (global)
         self.preset = kwargs.get("preset", None)  # PresetItem
         self.prompt = kwargs.get("prompt", "")
-        self.reply_context = kwargs.get("reply_ctx", None)  # ReplyContext
+        self.reply_context = kwargs.get("reply_ctx", kwargs.get("reply_context", None))  # ReplyContext
         self.request = kwargs.get("request", False)  # Use normal request instead of quick call
         self.stream = kwargs.get("stream", False)
         self.system_prompt = kwargs.get("system_prompt", "")
         self.system_prompt_raw = kwargs.get("system_prompt_raw", "")  # without plugins addons
         self.temperature = kwargs.get("temperature", 1.0)
         self.thread_id = kwargs.get("thread_id", "")
-        self.tools_outputs = kwargs.get("tools_outputs", [])
+        self.tools_outputs = list(kwargs.get("tools_outputs", []))
 
         # check types
         if self.ctx is not None and not isinstance(self.ctx, CtxItem):
@@ -101,36 +172,10 @@ class BridgeContext:
         """
         try:
             return json.dumps(self.to_dict(), ensure_ascii=False, indent=2)
-        except Exception as e:
+        except Exception:
             pass
         return ""
 
     def __str__(self):
         """To string"""
-        return self.dump()
-
-class MultimodalContext:
-    def __init__(self, **kwargs):
-        """
-        Multimodal context
-
-        :param kwargs: keyword arguments
-        """
-        self.is_audio_input = kwargs.get("is_audio_input", False)
-        self.is_audio_output = kwargs.get("is_audio_output", False)
-        self.audio_data = kwargs.get("audio_data", None)
-        self.audio_format = kwargs.get("audio_format", "wav")
-
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Return as dictionary
-
-        :return: dictionary
-        """
-        data = {
-            "is_audio_input": self.is_audio_input,
-            "is_audio_output": self.is_audio_output,
-            "audio_format": self.audio_format,
-        }
-        # sort by keys
-        return dict(sorted(data.items(), key=lambda item: item[0]))
+        return self.dump()

pygpt_net/core/bridge/worker.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.30 06:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import QObject, Signal, QRunnable, Slot
@@ -29,6 +29,8 @@ class BridgeSignals(QObject):
 
 
 class BridgeWorker(QRunnable):
+    __slots__ = ('signals', 'rt_signals', 'args', 'kwargs', 'window', 'context', 'extra', 'mode')
+
     """Bridge worker"""
     def __init__(self, *args, **kwargs):
         super().__init__()

pygpt_net/core/ctx/bag.py

@@ -15,9 +15,13 @@ from pygpt_net.item.ctx import CtxItem
 
 
 class Bag:
+    __slots__ = ('window', 'meta', 'tab_id', 'items')
+
     def __init__(self, window=None):
         """
         Context bag
+
+        :param window: Window instance
         """
         self.window = window
         self.meta = None  # current meta

pygpt_net/core/events/app.py

@@ -6,15 +6,22 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.23 21:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
-from typing import Optional
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, ClassVar
 
 from .base import BaseEvent
+from ...item.ctx import CtxItem
 
+
+@dataclass(slots=True)
 class AppEvent(BaseEvent):
     """Events dispatched by application"""
+    # static id for event family
+    id: ClassVar[str] = "AppEvent"
+
     APP_STARTED = "app.started"
     CAMERA_CAPTURED = "camera.captured"
     CAMERA_DISABLED = "camera.disabled"
@@ -37,18 +44,4 @@ class AppEvent(BaseEvent):
     VOICE_CONTROL_STOPPED = "voice.control.stopped"
     VOICE_CONTROL_SENT = "voice.control.sent"
     VOICE_CONTROL_TOGGLE = "voice.control.toggle"
-    VOICE_CONTROL_UNRECOGNIZED = "voice.control.unrecognized"
-
-    def __init__(
-            self,
-            name: Optional[str] = None,
-            data: Optional[dict] = None,
-    ):
-        """
-        Event object class
-
-        :param name: event name
-        :param data: event data
-        """
-        super(AppEvent, self).__init__(name, data)
-        self.id = "AppEvent"
+    VOICE_CONTROL_UNRECOGNIZED = "voice.control.unrecognized"

pygpt_net/core/events/base.py

@@ -6,39 +6,31 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.06 19:00:00                  #
+# Updated Date: 2025.09.04 00:00:00                  #
 # ================================================== #
 
 import json
-from typing import Optional, Dict, Any
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, ClassVar
 
 from pygpt_net.item.ctx import CtxItem
 
-class BaseEvent:
 
-    def __init__(
-            self,
-            name: Optional[str] = None,
-            data: Optional[dict] = None,
-            ctx: CtxItem = None
-    ):
-        """
-        Base Event object class
+@dataclass(slots=True)
+class BaseEvent:
+    """Base Event object class"""
+    id: ClassVar[str] = None
+    name: Optional[str] = None
+    data: Optional[dict] = None
+    ctx: Optional[CtxItem] = None  # CtxItem
+    stop: bool = False  # True to stop propagation
+    internal: bool = False
+    call_id: int = 0
 
-        :param name: event name
-        :param data: event data
-        :param ctx: context instance
-        """
-        self.id = None
-        self.name = name
-        self.data = data
+    def __post_init__(self):
+        # Normalize None to empty dict for convenience and safety
         if self.data is None:
             self.data = {}
-        self.ctx = ctx  # CtxItem
-        self.stop = False  # True to stop propagation
-        self.internal = False
-        self.call_id = 0
-
 
     @property
     def full_name(self) -> str:
@@ -47,7 +39,7 @@ class BaseEvent:
 
         :return: Full event name
         """
-        return self.id + ": " + self.name
+        return self.id + ": " + self.name  # type: ignore[operator]
 
     def to_dict(self) -> Dict[str, Any]:
         """Dump event to dict"""
@@ -66,7 +58,7 @@ class BaseEvent:
         """
         try:
             return json.dumps(self.to_dict())
-        except Exception as e:
+        except Exception:
             pass
         return ""