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

pygpt_net/core/audio/backend/pyaudio/realtime.py

@@ -1,14 +1,3 @@
-#!/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.08.31 23:00:00                  #
-# ================================================== #
-
 import threading
 from typing import Optional
 
@@ -53,6 +42,9 @@ class RealtimeSessionPyAudio(QObject):
         self._final = False
         self._tail_ms = 60  # add a small silence tail to avoid clicks
 
+        # one-shot guard to avoid double stop and duplicate callbacks
+        self._stopping = False
+
         # volume metering
         self._volume_emitter = volume_emitter
         self._vol_buffer = bytearray()
@@ -78,6 +70,13 @@ class RealtimeSessionPyAudio(QObject):
         except Exception:
             pass
 
+        # finished-state watchdog: guarantees stop()+on_stopped once playback is truly done
+        self._finish_timer = QTimer(self)
+        self._finish_timer.setTimerType(Qt.PreciseTimer)
+        self._finish_timer.setInterval(15)  # fast but lightweight watchdog
+        self._finish_timer.timeout.connect(self._check_finished)
+        self._finish_timer.start()
+
         # stop callback (set by backend)
         self.on_stopped = None
 
@@ -124,15 +123,28 @@ class RealtimeSessionPyAudio(QObject):
         self._final = True
 
     def stop(self) -> None:
-        """Stop playback and free resources."""
+        """Stop playback and free resources. Idempotent."""
+        # ensure this executes only once even if called from multiple paths
+        if self._stopping:
+            return
+        self._stopping = True
+
+        # stop timers first to prevent re-entry
+        try:
+            if self._finish_timer:
+                self._finish_timer.stop()
+        except Exception:
+            pass
         try:
             if self._vol_timer:
                 self._vol_timer.stop()
         except Exception:
             pass
+
+        # gracefully stop PortAudio stream and close/terminate
         try:
             if self._stream and self._stream.is_active():
-                self._stream.stop_stream()
+                self._stream.stop_stream()  # drains queued audio per PortAudio docs
         except Exception:
             pass
         try:
@@ -197,11 +209,36 @@ class RealtimeSessionPyAudio(QObject):
 
         # auto-finish: when final and nothing more to play, complete and stop()
         if self._final and self._buffer_empty():
-            QTimer.singleShot(0, self.stop)  # stop on the GUI thread
+            # Return paComplete and request stop on the GUI thread.
+            # PaComplete deactivates the stream after the last callback buffer is played.
+            QTimer.singleShot(0, self.stop)
             return out, pyaudio.paComplete
 
         return out, pyaudio.paContinue
 
+    def _check_finished(self) -> None:
+        """
+        Watchdog that runs on the Qt thread to guarantee a single, reliable stop().
+        Triggers when PortAudio deactivates the stream, or when the buffer is fully
+        drained after mark_final().
+        """
+        if self._stopping:
+            return
+
+        # If underlying PA stream is no longer active, we are done.
+        try:
+            if self._stream is not None and not self._stream.is_active():
+                self.stop()
+                return
+        except Exception:
+            # If querying state fails, assume the stream is done and stop.
+            self.stop()
+            return
+
+        # If we've been marked final and our buffer is empty, finalize proactively.
+        if self._final and self._buffer_empty():
+            self.stop()
+
     def _buffer_empty(self) -> bool:
         """
         Check if internal buffer is empty.

pygpt_net/core/audio/output.py

@@ -43,8 +43,9 @@ class Output:
         return self.backends[backend]
 
     def setup(self):
-        """Setup audio output backend"""
-        pass
+        """Setup audio input backend"""
+        for b in self.backends.values():
+            b.set_rt_signals(self.window.controller.realtime.signals)
 
     def play(
             self,

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

pygpt_net/core/image/image.py

@@ -6,13 +6,13 @@
 # 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.01 23:00:00                  #
 # ================================================== #
 
-import os
 import uuid
-from time import strftime
+import os
 from typing import List, Dict
+from time import strftime
 
 from PySide6.QtCore import Slot, QObject
 
@@ -73,7 +73,7 @@ class Image(QObject):
             prompt,
         )
 
-    @Slot()
+    @Slot(object)
     def handle_status(self, msg: str):
         """
         Handle thread status message
@@ -90,7 +90,7 @@ class Image(QObject):
         if is_log:
             print(msg)
 
-    @Slot()
+    @Slot(object)
     def handle_error(self, msg: any):
         """
         Handle thread error message
@@ -99,6 +99,7 @@ class Image(QObject):
         """
         self.window.update_status(msg)
         self.window.core.debug.log(msg)
+        self.window.ui.dialogs.alert(msg)
 
     def save_image(self, path: str, image: bytes) -> bool:
         """

pygpt_net/core/realtime/worker.py

@@ -134,11 +134,7 @@ class RealtimeWorker(QRunnable):
                 event = RealtimeEvent(RealtimeEvent.RT_OUTPUT_AUDIO_ERROR, {"error": e})
                 self.opts.rt_signals.response.emit(event) if self.opts.rt_signals else None
             finally:
-                try:
-                    event = RealtimeEvent(RealtimeEvent.RT_OUTPUT_AUDIO_END, {"ctx": self.ctx})
-                    self.opts.rt_signals.response.emit(event) if self.opts.rt_signals else None
-                except Exception:
-                    pass
+                pass
         finally:
             # Robust asyncio teardown to avoid hangs on subsequent runs
             if loop is not None: