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

pygpt_net/core/camera/worker.py

@@ -0,0 +1,430 @@
+#!/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 16:00:00                  #
+# ================================================== #
+
+import time
+
+from PySide6.QtCore import QObject, Signal, QRunnable, Slot, QEventLoop, QTimer, Qt
+from PySide6.QtGui import QImage
+
+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
+
+        # Common
+        self.initialized = False
+        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.
+
+        :param device: QCameraDevice
+        :param target_w: target width
+        :param target_h: target height
+        """
+        try:
+            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') or 0)
+            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(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):
+        """Run capture using Qt first; fall back to OpenCV if needed."""
+        self.allow_finish = True
+        self._last_emit = 0.0
+
+        used_backend = None
+        try:
+            # 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:
+            # 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 _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
+        try:
+            if sig is not None:
+                sig.deleteLater()
+        except RuntimeError:
+            pass

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 ""
 

pygpt_net/core/events/control.py

@@ -6,16 +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, ClassVar
 
 from .base import BaseEvent
+from ...item.ctx import CtxItem
 
 
+@dataclass(slots=True)
 class ControlEvent(BaseEvent):
     """Events used for app control"""
+    # static id for event family
+    id: ClassVar[str] = "ControlEvent"
+
     APP_EXIT = "app.exit"
     APP_STATUS = "app.status"
     AUDIO_INPUT_DISABLE = "audio.input.disable"
@@ -72,18 +78,4 @@ class ControlEvent(BaseEvent):
     VOICE_CONTROL_UNRECOGNIZED = "unrecognized"
     VOICE_MESSAGE_START = "voice_msg.start"
     VOICE_MESSAGE_STOP = "voice_msg.stop"
-    VOICE_MESSAGE_TOGGLE = "voice_msg.toggle"
-
-    def __init__(
-            self,
-            name: Optional[str] = None,
-            data: Optional[dict] = None,
-    ):
-        """
-        Event object class
-
-        :param name: event name
-        :param data: event data
-        """
-        super(ControlEvent, self).__init__(name, data)
-        self.id = "ControlEvent"
+    VOICE_MESSAGE_TOGGLE = "voice_msg.toggle"

pygpt_net/core/events/event.py

@@ -6,16 +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                  #
 # ================================================== #
 
 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
 from .base import BaseEvent
 
+
+@dataclass(slots=True)
 class Event(BaseEvent):
+    """Generic event with context serialization"""
+    # static id for event family
+    id: ClassVar[str] = "Event"
 
     # Events
     AI_NAME = "ai.name"
@@ -63,63 +69,4 @@ class Event(BaseEvent):
     UI_ATTACHMENTS = "ui.attachments"
     UI_VISION = "ui.vision"
     USER_NAME = "user.name"
-    USER_SEND = "user.send"
-
-    def __init__(
-            self,
-            name: Optional[str] = None,
-            data: Optional[dict] = None,
-            ctx: Optional[CtxItem] = None
-    ):
-        """
-        Event object class
-
-        :param name: event name
-        :param data: event data
-        :param ctx: context instance
-        """
-        super(Event, self).__init__(name, data, ctx)
-        self.id = "Event"
-        self.name = name
-        self.data = data
-        if self.data is None:
-            self.data = {}
-        self.ctx = ctx  # CtxItem
-        self.stop = False  # True to stop propagation
-        self.internal = False
-        # internal event, not called from user
-        # internal event is handled synchronously, ctx item has internal flag
-
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Dump event to dict
-
-        :return: Event dict
-        """
-        return {
-            'name': self.name,
-            'data': self.data,
-            'ctx': self.ctx.to_dict() if self.ctx else None,
-            'stop': self.stop,
-            'internal': self.internal,
-        }
-
-    def dump(self) -> str:
-        """
-        Dump event to json string
-
-        :return: JSON string
-        """
-        try:
-            return json.dumps(self.to_dict())
-        except Exception as e:
-            pass
-        return ""
-
-    def __str__(self) -> str:
-        """
-        String representation of event
-
-        :return: Event string
-        """
-        return self.dump()
+    USER_SEND = "user.send"