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

pygpt_net/controller/painter/common.py

@@ -6,13 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.14 08:00:00                  #
+# Updated Date: 2025.09.02 20: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:
@@ -23,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]:
         """
@@ -37,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))
 
@@ -49,8 +56,11 @@ class Common:
         :param enabled: bool
         """
         if enabled:
+            # keep UI color for compatibility
             self.window.ui.nodes['painter.select.brush.color'].setCurrentText("Black")
             self.window.ui.painter.set_brush_color(Qt.black)
+            # switch widget to brush mode (layered painting)
+            self.window.ui.painter.set_mode("brush")
             self.window.core.config.set('painter.brush.mode', "brush")
             self.window.core.config.save()
 
@@ -61,8 +71,11 @@ class Common:
         :param enabled: bool
         """
         if enabled:
+            # keep UI color for compatibility
             self.window.ui.nodes['painter.select.brush.color'].setCurrentText("White")
             self.window.ui.painter.set_brush_color(Qt.white)
+            # switch widget to erase mode (layered erasing)
+            self.window.ui.painter.set_mode("erase")
             self.window.core.config.set('painter.brush.mode', "erase")
             self.window.core.config.save()
 
@@ -72,14 +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)
-            self.window.ui.nodes['painter.select.canvas.size'].setCurrentText(selected)
-            self.set_canvas_size(size[0], size[1])
-            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):
         """
@@ -142,7 +205,7 @@ 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 get_colors(self) -> Dict[str, QColor]:
@@ -193,3 +256,157 @@ class Common:
         :return: path to capture directory
         """
         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,13 +1,4 @@
-#!/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: 2024.11.20 21:00:00                  #
-# ================================================== #
+# controller/painter/painter.py
 
 import os
 
@@ -72,7 +63,8 @@ class Painter:
             return
         path = os.path.join(self.common.get_capture_dir(), '_current.png')
         if os.path.exists(path):
-            self.window.ui.painter.image.load(path)
+            # load as flat source; layers will be rebuilt on canvas resize
+            self.window.ui.painter.load_flat_image(path)
         else:
             # clear image
             self.window.ui.painter.clear_image()
@@ -88,4 +80,4 @@ class Painter:
 
     def reload(self):
         """Reload painter"""
-        self.setup()
+        self.setup()

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/camera/camera.py

@@ -6,13 +6,11 @@
 # 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.09.02 16:00:00                  #
 # ================================================== #
 
 import os
-import time
-
-from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+from typing import List
 
 
 class Camera:
@@ -32,103 +30,50 @@ class Camera:
         if not os.path.exists(img_dir):
             os.makedirs(img_dir, exist_ok=True)
 
+    def get_devices_data(self) -> List[dict]:
+        """
+        Return a list of camera devices for UI selection.
 
-class CaptureSignals(QObject):
-    finished = Signal()
-    unfinished = Signal()
-    destroyed = Signal()
-    started = Signal()
-    stopped = Signal()
-    capture = Signal(object)
-    error = Signal(object)
-
-
-class CaptureWorker(QRunnable):
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-        self.signals = CaptureSignals()
-        self.args = args
-        self.kwargs = kwargs
-        self.window = None
-        self.initialized = False
-        self.capture = None
-        self.frame = None
-        self.allow_finish = False
+        Format:
+        [
+            {'id': <int index>, 'name': <str description>},
+            ...
+        ]
 
-    def setup_camera(self):
-        """Initialize camera"""
+        'id' is the ordinal index used by vision.capture.idx.
+        """
         try:
-            import cv2
-            # get params from global config
-            self.capture = cv2.VideoCapture(self.window.core.config.get('vision.capture.idx'))
-            if not self.capture or not self.capture.isOpened():
-                self.allow_finish = False
-                self.signals.unfinished.emit()
-                return
-            self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, self.window.core.config.get('vision.capture.width'))
-            self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, self.window.core.config.get('vision.capture.height'))
+            from PySide6.QtMultimedia import QMediaDevices
         except Exception as e:
+            # Qt Multimedia not available
             self.window.core.debug.log(e)
-            if self.signals is not None:
-                self.signals.error.emit(e)
-                self.signals.finished.emit(e)
+            return []
 
-    @Slot()
-    def run(self):
-        """Frame capture loop"""
-        target_fps = 30
-        fps_interval = 1.0 / target_fps
-        self.allow_finish = True
         try:
-            import cv2
-            if not self.initialized:
-                self.setup_camera()
-                self.signals.started.emit()
-                self.initialized = True
-            last_frame_time = time.time()
-            while True:
-                if self.window.is_closing \
-                        or self.capture is None \
-                        or not self.capture.isOpened() \
-                        or self.window.controller.camera.stop:
-                    self.release()  # release camera
-                    self.signals.stopped.emit()
-                    break
-                _, frame = self.capture.read()
-                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                now = time.time()
-                if now - last_frame_time >= fps_interval:
-                    self.signals.capture.emit(frame)
-                    last_frame_time = now
-
+            devices = list(QMediaDevices.videoInputs())
         except Exception as e:
             self.window.core.debug.log(e)
-            if self.signals is not None:
-                self.signals.error.emit(e)
-
-        finally:
-            self.release()  # release camera
-            if self.signals is not None:
-                if self.allow_finish:
-                    self.signals.finished.emit()
-                else:
-                    self.signals.unfinished.emit()
-            self.cleanup()
-
-    def release(self):
-        """Release camera"""
-        if self.capture is not None and self.capture.isOpened():
-            self.capture.release()
-            self.capture = None
-            self.frame = None
-            self.initialized = False
+            return []
 
-    def cleanup(self):
-        """Cleanup resources after worker execution."""
-        sig = self.signals
-        self.signals = None
-        if sig is not None:
+        result = []
+        for idx, dev in enumerate(devices):
             try:
-                sig.deleteLater()
-            except RuntimeError:
-                pass
+                name = dev.description()
+            except Exception:
+                name = f"Camera {idx}"
+            result.append({'id': idx, 'name': name})
+        return result
+
+    def get_devices(self) -> List[dict]:
+        """
+        Get choices list of single-pair dicts {id: name}.
+
+        Example:
+        [
+            {'0': 'Integrated Camera'},
+            {'1': 'USB Camera'},
+            ...
+        ]
+        """
+        items = self.get_devices_data()
+        return [{str(item['id']): item['name']} for item in items]