pygpt-net 2.6.33__py3-none-any.whl → 2.6.36__py3-none-any.whl

pygpt_net/controller/painter/common.py

@@ -1,9 +1,19 @@
-# controller/painter/common.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                  #
+# ================================================== #
 
 from typing import Tuple, Optional, Dict, List
 
 from PySide6.QtCore import Qt, QSize
 from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QComboBox
 
 
 class Common:
@@ -14,6 +24,12 @@ class Common:
         :param window: Window instance
         """
         self.window = window
+        # Guard to prevent re-entrancy when programmatically changing the combo/size
+        self._changing_canvas_size = False
+        # Cached set for predefined canvas sizes
+        self._predef_canvas_sizes_set = None
+        # Sticky custom value derived from the current "source" image (kept at index 0 when present)
+        self._sticky_custom_value: Optional[str] = None
 
     def convert_to_size(self, canvas_size: str) -> Tuple[int, int]:
         """
@@ -28,8 +44,8 @@ class Common:
         """
         Set canvas size
 
-        :param width: int
-        :param height: int
+        :param width: Canvas width
+        :param height: Canvas height
         """
         self.window.ui.painter.setFixedSize(QSize(width, height))
 
@@ -69,16 +85,64 @@ class Common:
 
         :param selected: Selected size
         """
+        # Re-entrancy guard to avoid loops when we adjust the combo programmatically
+        if self._changing_canvas_size:
+            return
+
+        combo: QComboBox = self.window.ui.nodes['painter.select.canvas.size']
+        painter = self.window.ui.painter
+
+        # Heuristic to detect manual UI change vs programmatic call
+        # - manual if: no arg, or int index (Qt int overload), or arg equals currentText/currentData
+        raw_arg = selected
+        current_text = combo.currentText()
+        current_data = combo.currentData()
+        current_data_str = current_data if isinstance(current_data, str) else None
+        is_manual = (
+            raw_arg is None
+            or isinstance(raw_arg, int)
+            or (isinstance(raw_arg, str) and (raw_arg == current_text or (current_data_str and raw_arg == current_data_str)))
+        )
+
+        # Resolve selection if not passed explicitly; fallback to currentText if userData is missing
         if not selected:
-            selected = self.window.ui.nodes['painter.select.canvas.size'].currentData()
-        if selected:
-            size = self.convert_to_size(selected)
-            # setCurrentText might not exist in the combo's items for custom sizes; harmless if it doesn't match
-            self.window.ui.nodes['painter.select.canvas.size'].setCurrentText(selected)
-            self.set_canvas_size(size[0], size[1])
-            # resizing the widget triggers automatic image rescale in PainterWidget.resizeEvent
-            self.window.core.config.set('painter.canvas.size', selected)
+            selected = current_data_str or current_text
+
+        # Normalize to "WxH" strictly; if invalid, do nothing
+        selected_norm = self._normalize_canvas_value(selected)
+        if not selected_norm:
+            return
+
+        # Save undo only for manual changes and only if size will change
+        will_change = selected_norm != f"{painter.width()}x{painter.height()}"
+        if is_manual and will_change:
+            painter.saveForUndo()
+
+        try:
+            self._changing_canvas_size = True
+
+            predef = self._get_predef_canvas_set()
+
+            # Sticky custom update only for programmatic (source-driven) changes
+            programmatic = not is_manual
+            if programmatic:
+                if selected_norm in predef:
+                    self._sticky_custom_value = None
+                else:
+                    self._sticky_custom_value = selected_norm
+
+            # Ensure combo reflects single custom at index 0 (sticky respected), then select current value
+            self._sync_canvas_size_combo(combo, selected_norm, sticky_to_keep=self._sticky_custom_value)
+
+            # Apply canvas size; PainterWidget handles rescaling in resizeEvent
+            w, h = self.convert_to_size(selected_norm)
+            self.set_canvas_size(w, h)
+
+            # Persist normalized value
+            self.window.core.config.set('painter.canvas.size', selected_norm)
             self.window.core.config.save()
+        finally:
+            self._changing_canvas_size = False
 
     def change_brush_size(self, size: int):
         """
@@ -141,9 +205,21 @@ class Common:
         if self.window.core.config.has('painter.brush.size'):
             size = int(self.window.core.config.get('painter.brush.size', 3))
         self.window.ui.nodes['painter.select.brush.size'].setCurrentIndex(
-                self.window.ui.nodes['painter.select.brush.size'].findText(str(size))
+            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
@@ -191,4 +267,158 @@ class Common:
 
         :return: path to capture directory
         """
-        return self.window.core.config.get_user_dir('capture')
+        return self.window.core.config.get_user_dir('capture')
+
+    # ---------- Public sync helper (used by PainterWidget undo/redo) ----------
+
+    def sync_canvas_combo_from_widget(self):
+        """
+        Sync the size combobox with current PainterWidget canvas size.
+        Also derive sticky custom from the current source image if it is custom.
+        This method does not change the canvas size (UI-only sync).
+        """
+        if self._changing_canvas_size:
+            return
+
+        combo: QComboBox = self.window.ui.nodes['painter.select.canvas.size']
+        painter = self.window.ui.painter
+
+        canvas_value = f"{painter.width()}x{painter.height()}"
+        canvas_norm = self._normalize_canvas_value(canvas_value)
+        if not canvas_norm:
+            return
+
+        # Derive sticky from current source image (if custom)
+        predef = self._get_predef_canvas_set()
+        sticky = None
+        if painter.sourceImageOriginal is not None and not painter.sourceImageOriginal.isNull():
+            src_val = f"{painter.sourceImageOriginal.width()}x{painter.sourceImageOriginal.height()}"
+            src_val = self._normalize_canvas_value(src_val)
+            if src_val and src_val not in predef:
+                sticky = src_val
+
+        try:
+            self._changing_canvas_size = True
+            self._sticky_custom_value = sticky
+            self._sync_canvas_size_combo(combo, canvas_norm, sticky_to_keep=sticky)
+
+            # Persist canvas size only (do not change sticky config-scope)
+            self.window.core.config.set('painter.canvas.size', canvas_norm)
+            self.window.core.config.save()
+        finally:
+            self._changing_canvas_size = False
+
+    # ---------- Internal helpers ----------
+
+    def _normalize_canvas_value(self, value: Optional[str]) -> Optional[str]:
+        """
+        Normalize arbitrary canvas string to canonical 'WxH'. Returns None if invalid.
+        Accepts variants like ' 1024 x 768 ', '1024×768', etc.
+
+        :param value: input value
+        :return: normalized value or None
+        """
+        if not value:
+            return None
+        s = str(value).strip().lower().replace(' ', '').replace('×', 'x')
+        if 'x' not in s:
+            return None
+        parts = s.split('x', 1)
+        try:
+            w = int(parts[0])
+            h = int(parts[1])
+        except Exception:
+            return None
+        if w <= 0 or h <= 0:
+            return None
+        return f"{w}x{h}"
+
+    def _get_predef_canvas_set(self) -> set:
+        """
+        Return cached set of predefined sizes for O(1) lookups.
+
+        :return: set of predefined sizes
+        """
+        if self._predef_canvas_sizes_set is None:
+            self._predef_canvas_sizes_set = set(self.get_canvas_sizes())
+        return self._predef_canvas_sizes_set
+
+    def _find_index_for_value(self, combo: QComboBox, value: str) -> int:
+        """
+        Find index by userData first, then by text. Returns -1 if not found.
+
+        :param combo: QComboBox
+        :param value: value to find
+        :return: index or -1
+        """
+        idx = combo.findData(value)
+        if idx == -1:
+            idx = combo.findText(value, Qt.MatchFixedString)
+        return idx
+
+    def _remove_extra_custom_items(self, combo: QComboBox, predef: set, keep_index: int = -1):
+        """
+        Remove all non-predefined items except one at keep_index (if set).
+
+        :param combo: QComboBox
+        :param predef: set of predefined values
+        :param keep_index: index to keep even if custom, or -1 to remove all custom
+        """
+        for i in range(combo.count() - 1, -1, -1):
+            if i == keep_index:
+                continue
+            txt = combo.itemText(i)
+            if txt not in predef:
+                combo.removeItem(i)
+
+    def _ensure_custom_index0(self, combo: QComboBox, custom_value: str, predef: set):
+        """
+        Ensure exactly one custom item exists at index 0 with given value.
+
+        :param combo: QComboBox
+        :param custom_value: custom value to set at index 0
+        :param predef: set of predefined values
+        """
+        if combo.count() > 0 and combo.itemText(0) not in predef:
+            if combo.itemText(0) != custom_value:
+                combo.setItemText(0, custom_value)
+                combo.setItemData(0, custom_value)
+        else:
+            combo.insertItem(0, custom_value, custom_value)
+        self._remove_extra_custom_items(combo, predef, keep_index=0)
+
+    def _sync_canvas_size_combo(self, combo: QComboBox, value: str, sticky_to_keep: Optional[str]):
+        """
+        Enforce invariant and selection:
+        - If sticky_to_keep is a custom value -> keep it as single custom item at index 0.
+        - If sticky_to_keep is None -> remove all custom items.
+        - Select 'value' in the combo. If value is custom and sticky_to_keep differs or is None,
+          ensure index 0 matches 'value' and select it.
+
+        :param combo: QComboBox
+        :param value: current canvas size value to select
+        :param sticky_to_keep: sticky custom value to keep at index 0, or None
+        """
+        predef = self._get_predef_canvas_set()
+
+        # Maintain sticky custom slot (index 0) if provided
+        if sticky_to_keep and sticky_to_keep not in predef:
+            self._ensure_custom_index0(combo, sticky_to_keep, predef)
+        else:
+            self._remove_extra_custom_items(combo, predef, keep_index=-1)
+
+        # Select the current canvas value
+        if value in predef:
+            idx = self._find_index_for_value(combo, value)
+            if idx != -1 and idx != combo.currentIndex():
+                combo.setCurrentIndex(idx)
+            elif idx == -1:
+                # Fallback: set text (should not normally happen if combo prepopulates predefined sizes)
+                combo.setCurrentText(value)
+        else:
+            # Current value is custom: ensure it exists at index 0 and select it
+            # If sticky differs or is None, overwrite/create the custom at index 0 to reflect true current value.
+            if not sticky_to_keep or sticky_to_keep != value:
+                self._ensure_custom_index0(combo, value, predef)
+            if combo.currentIndex() != 0:
+                combo.setCurrentIndex(0)

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/assistants/files.py

@@ -257,6 +257,24 @@ class Files:
             del self.items[file.record_id]
         return True
 
+    def delete_by_file_id(self, file_id: str) -> bool:
+        """
+        Delete file by file ID
+
+        :param file_id: file ID
+        :return: True if deleted
+        """
+        res = self.provider.delete_by_file_id(file_id)
+        if res:
+            # remove from items
+            to_delete = []
+            for id in self.items:
+                if self.items[id].file_id == file_id:
+                    to_delete.append(id)
+            for id in to_delete:
+                del self.items[id]
+        return res
+
     def on_store_deleted(self, store_id: str):
         """
         Clear deleted store from files

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__()