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

pygpt_net/CHANGELOG.txt

@@ -1,3 +1,8 @@
+2.6.33 (2025-09-02)
+
+- Added a "crop" option, auto-resize canvas, and layer support to Painter.
+- Improved video capture from the camera.
+
 2.6.32 (2025-09-02)
 
 - Added video generation and support for Google Veo 3 models.

pygpt_net/__init__.py

@@ -13,7 +13,7 @@ __author__ = "Marcin Szczygliński"
 __copyright__ = "Copyright 2025, Marcin Szczygliński"
 __credits__ = ["Marcin Szczygliński"]
 __license__ = "MIT"
-__version__ = "2.6.32"
+__version__ = "2.6.33"
 __build__ = "2025-09-02"
 __maintainer__ = "Marcin Szczygliński"
 __github__ = "https://github.com/szczyglis-dev/py-gpt"

pygpt_net/controller/chat/attachment.py

@@ -126,6 +126,8 @@ class Attachment(QObject):
         self.uploaded = False
         auto_index = self.window.core.config.get("attachments_auto_index", False)
         attachments = self.window.core.attachments.get_all(mode, only_files=True)
+        if self.mode != self.MODE_QUERY_CONTEXT:
+            auto_index = False  # disable auto index for full context and summary modes
 
         if self.is_verbose() and len(attachments) > 0:
             print(f"\nUploading attachments...\nWork Mode: {mode}")

pygpt_net/controller/painter/common.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.12.14 08:00:00                  #
-# ================================================== #
+# controller/painter/common.py
 
 from typing import Tuple, Optional, Dict, List
 
@@ -49,8 +40,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 +55,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()
 
@@ -76,8 +73,10 @@ class Common:
             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)
             self.window.core.config.save()
 
@@ -192,4 +191,4 @@ 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')

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

@@ -6,13 +6,14 @@
 # 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 09:00:00                  #
 # ================================================== #
 
 import os
 import time
 
-from PySide6.QtCore import QObject, Signal, QRunnable, Slot
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot, QEventLoop, QTimer, Qt
+from PySide6.QtGui import QImage
 
 
 class Camera:
@@ -50,85 +51,400 @@ class CaptureWorker(QRunnable):
         self.args = args
         self.kwargs = kwargs
         self.window = None
+
+        # Common
         self.initialized = False
-        self.capture = None
-        self.frame = None
         self.allow_finish = False
+        self._fps_interval = 1.0 / 30.0  # default 30 FPS throttle
+
+        # Qt Multimedia objects (created in worker thread)
+        self.session = None
+        self.camera = None
+        self.sink = None
+        self.loop = None
+        self.poll_timer = None
+        self._qt_got_first_frame = False
+        self._probe_loop = None
+
+        # OpenCV fallback
+        self.cv_cap = None
+
+        # Timing (shared)
+        self._last_emit = 0.0
+
+    # =========================
+    # Qt Multimedia path
+    # =========================
+    def _select_camera_format(self, device, target_w: int, target_h: int):
+        """
+        Select best matching camera format by resolution.
 
-    def setup_camera(self):
-        """Initialize camera"""
+        :param device: QCameraDevice
+        :param target_w: target width
+        :param target_h: target height
+        """
         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'))
+            formats = list(device.videoFormats())
+        except Exception:
+            formats = []
+        if not formats:
+            return None
+
+        best = None
+        best_score = float('inf')
+        for f in formats:
+            res = f.resolution()
+            w, h = res.width(), res.height()
+            score = abs(w - target_w) + abs(h - target_h)
+            if score < best_score:
+                best_score = score
+                best = f
+        return best
+
+    def _init_qt(self) -> bool:
+        """
+        Try to initialize Qt camera pipeline.
+
+        :return: True if initialized
+        """
+        try:
+            from PySide6.QtMultimedia import (
+                QCamera,
+                QMediaDevices,
+                QMediaCaptureSession,
+                QVideoSink,
+            )
+
+            idx = int(self.window.core.config.get('vision.capture.idx'))
+            target_w = int(self.window.core.config.get('vision.capture.width'))
+            target_h = int(self.window.core.config.get('vision.capture.height'))
+            target_fps = 30
+            self._fps_interval = 1.0 / float(target_fps)
+
+            devices = list(QMediaDevices.videoInputs())
+            if not devices:
+                return False
+
+            if idx < 0 or idx >= len(devices):
+                idx = 0
+            dev = devices[idx]
+
+            self.camera = QCamera(dev)
+            fmt = self._select_camera_format(dev, target_w, target_h)
+            if fmt is not None:
+                self.camera.setCameraFormat(fmt)
+
+            self.session = QMediaCaptureSession()
+            self.session.setCamera(self.camera)
+
+            self.sink = QVideoSink()
+            self.sink.videoFrameChanged.connect(self.on_qt_frame_changed, Qt.DirectConnection)
+            self.session.setVideoOutput(self.sink)
+
+            self.camera.errorOccurred.connect(self._on_qt_camera_error, Qt.QueuedConnection)
+            return True
+
         except Exception as e:
+            # Qt Multimedia not available or failed to init
             self.window.core.debug.log(e)
+            return False
+
+    def _teardown_qt(self):
+        """Release Qt camera pipeline."""
+        try:
+            if self.sink is not None:
+                try:
+                    self.sink.videoFrameChanged.disconnect(self.on_qt_frame_changed)
+                except Exception:
+                    pass
+            if self.camera is not None and self.camera.isActive():
+                self.camera.stop()
+        except Exception:
+            pass
+        finally:
+            self.sink = None
+            self.session = None
+            self.camera = None
+
+    def _probe_qt_start(self, timeout_ms: int = 1500) -> bool:
+        """
+        Wait briefly for the first frame to confirm Qt pipeline is working.
+
+        :param timeout_ms: timeout in milliseconds
+        :return: True if first frame received
+        """
+        try:
+            if self.camera is None:
+                return False
+
+            self._qt_got_first_frame = False
+            self._probe_loop = QEventLoop()
+
+            # Timeout quits the probe loop
+            QTimer.singleShot(timeout_ms, self._probe_loop.quit)
+
+            # Start camera and wait for first frame or timeout
+            self.camera.start()
+            self._probe_loop.exec()
+
+            got = self._qt_got_first_frame
+            self._probe_loop = None
+            return got
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return False
+
+    @Slot(object)
+    def _on_qt_camera_error(self, err):
+        """
+        Handle Qt camera errors.
+
+        :param err: error object
+        """
+        try:
+            # Stop loop if running
+            if self.loop is not None and self.loop.isRunning():
+                self.loop.quit()
+            if self._probe_loop is not None and self._probe_loop.isRunning():
+                self._probe_loop.quit()
+        except Exception:
+            pass
+        finally:
+            self.allow_finish = False
             if self.signals is not None:
-                self.signals.error.emit(e)
-                self.signals.finished.emit(e)
+                self.signals.error.emit(err)
+
+    @Slot(object)
+    def on_qt_frame_changed(self, video_frame):
+        """
+        Convert QVideoFrame to RGB numpy array and emit.
+
+        :param video_frame: QVideoFrame
+        """
+        try:
+            # Mark that we have a first frame for probe
+            if not self._qt_got_first_frame:
+                self._qt_got_first_frame = True
+                # If we are probing, quit the probe loop immediately
+                if self._probe_loop is not None and self._probe_loop.isRunning():
+                    self._probe_loop.quit()
+
+            # Throttle FPS for normal operation path
+            now = time.monotonic()
+            if self.loop is not None and self.loop.isRunning():
+                if (now - self._last_emit) < self._fps_interval:
+                    return
+
+            img = video_frame.toImage()
+            if img.isNull():
+                return
+
+            img = img.convertToFormat(QImage.Format.Format_RGB888)
+
+            w = img.width()
+            h = img.height()
+            bpl = img.bytesPerLine()
 
+            ptr = img.bits()
+            size = bpl * h
+            try:
+                ptr.setsize(size)
+            except Exception:
+                # Some bindings may not require setsize; ignore if unsupported
+                pass
+
+            import numpy as np
+            arr = np.frombuffer(ptr, dtype=np.uint8)
+
+            if bpl != w * 3:
+                arr = arr.reshape(h, bpl)[:, : w * 3]
+                arr = arr.reshape(h, w, 3).copy()
+            else:
+                arr = arr.reshape(h, w, 3).copy()
+
+            if self.signals is not None:
+                self.signals.capture.emit(arr)
+            self._last_emit = now
+
+        except Exception as e:
+            self.window.core.debug.log(e)
+
+    # =========================
+    # OpenCV fallback path
+    # =========================
+    def _init_cv2(self) -> bool:
+        """
+        Try to initialize OpenCV VideoCapture fallback.
+
+        :return: True if initialized
+        """
+        try:
+            import cv2
+            idx = int(self.window.core.config.get('vision.capture.idx'))
+            target_w = int(self.window.core.config.get('vision.capture.width'))
+            target_h = int(self.window.core.config.get('vision.capture.height'))
+            target_fps = 30
+            self._fps_interval = 1.0 / float(target_fps)
+
+            cap = cv2.VideoCapture(idx)
+            if not cap or not cap.isOpened():
+                return False
+
+            cap.set(cv2.CAP_PROP_FRAME_WIDTH, target_w)
+            cap.set(cv2.CAP_PROP_FRAME_HEIGHT, target_h)
+            self.cv_cap = cap
+            return True
+        except Exception as e:
+            self.window.core.debug.log(e)
+            return False
+
+    def _teardown_cv2(self):
+        """Release OpenCV capture."""
+        try:
+            if self.cv_cap is not None and self.cv_cap.isOpened():
+                self.cv_cap.release()
+        except Exception:
+            pass
+        finally:
+            self.cv_cap = None
+
+    # =========================
+    # Runner
+    # =========================
     @Slot()
     def run(self):
-        """Frame capture loop"""
-        target_fps = 30
-        fps_interval = 1.0 / target_fps
+        """Run capture using Qt first; fall back to OpenCV if needed."""
         self.allow_finish = True
+        self._last_emit = 0.0
+
+        used_backend = None
         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
+            # Try Qt Multimedia
+            if self._init_qt():
+                if self._probe_qt_start(timeout_ms=1500):
+                    # Qt confirmed working; start main event-driven loop
+                    used_backend = 'qt'
+                    self.initialized = True
+                    if self.signals is not None:
+                        self.signals.started.emit()
+
+                    self.loop = QEventLoop()
+
+                    self.poll_timer = QTimer()
+                    self.poll_timer.setTimerType(Qt.PreciseTimer)
+                    self.poll_timer.setInterval(30)
+                    self.poll_timer.timeout.connect(self._poll_stop_qt, Qt.DirectConnection)
+                    self.poll_timer.start()
+
+                    self.loop.exec()
+
+                    if self.signals is not None:
+                        self.signals.stopped.emit()
+                else:
+                    # Fallback to OpenCV if no frames arrive quickly
+                    print("QT camera init failed, trying CV2 fallback...")
+                    self._teardown_qt()
+            else:
+                # Qt init failed outright, fallback to CV2
+                print("QT camera init failed, trying CV2 fallback...")
+
+            # Try OpenCV fallback if Qt was not used
+            if used_backend is None:
+                if self._init_cv2():
+                    used_backend = 'cv2'
+                    self.initialized = True
+                    if self.signals is not None:
+                        self.signals.started.emit()
+
+                    import cv2
+                    target_fps = 30
+                    fps_interval = 1.0 / float(target_fps)
+                    last_frame_time = time.time()
+
+                    while True:
+                        if self._should_stop():
+                            break
+
+                        ok, frame = self.cv_cap.read()
+                        if not ok or frame is None:
+                            continue
+
+                        now = time.time()
+                        if now - last_frame_time >= fps_interval:
+                            # Convert BGR -> RGB for the controller/UI pipeline
+                            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                            if self.signals is not None:
+                                self.signals.capture.emit(frame)
+                            last_frame_time = now
+
+                    if self.signals is not None:
+                        self.signals.stopped.emit()
+                else:
+                    # Both providers failed
+                    self.allow_finish = False
 
         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
+            # Cleanup resources
+            try:
+                if self.poll_timer is not None:
+                    self.poll_timer.stop()
+            except Exception:
+                pass
+            self.poll_timer = None
+
+            if used_backend == 'qt':
+                self._teardown_qt()
+            else:
+                self._teardown_qt()  # no-op if not initialized
+                self._teardown_cv2()
+
+            # Emit final state
             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
+    def _poll_stop_qt(self):
+        """Check stop flags while running Qt pipeline."""
+        try:
+            if self._should_stop():
+                if self.camera is not None and self.camera.isActive():
+                    self.camera.stop()
+                if self.loop is not None and self.loop.isRunning():
+                    self.loop.quit()
+        except Exception as e:
+            self.window.core.debug.log(e)
+            if self.loop is not None and self.loop.isRunning():
+                self.loop.quit()
+
+    def _should_stop(self) -> bool:
+        """
+        Check external stop flags.
+
+        :return: True if should stop
+        """
+        try:
+            if getattr(self.window, 'is_closing', False):
+                return True
+            if self.window is not None and self.window.controller.camera.stop:
+                return True
+        except Exception:
+            return True
+        return False
 
     def cleanup(self):
         """Cleanup resources after worker execution."""
         sig = self.signals
         self.signals = None
-        if sig is not None:
-            try:
+        try:
+            if sig is not None:
                 sig.deleteLater()
-            except RuntimeError:
-                pass
+        except RuntimeError:
+            pass