pygpt-net 2.6.26__py3-none-any.whl → 2.6.28__py3-none-any.whl

pygpt_net/core/audio/backend/native.py

@@ -6,14 +6,19 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.07 22:00:00                  #
+# Updated Date: 2025.08.27 07:00:00                  #
 # ================================================== #
 
+from typing import List, Tuple
+
+from bs4 import UnicodeDammit
 import os
 import time
-from typing import List, Tuple
+import numpy as np
+import wave
 
-from PySide6.QtCore import QTimer, QObject
+from PySide6.QtMultimedia import QMediaPlayer, QAudioOutput, QMediaDevices, QAudioFormat, QAudioSource
+from PySide6.QtCore import QTimer, QObject, QUrl
 from pydub import AudioSegment
 
 
@@ -40,7 +45,6 @@ class NativeBackend(QObject):
         self.start_time = 0
         self.devices = []
         self.selected_device = None
-        self.bar = None
         self.loop = False
         self.stop_callback = None
         self.player = None
@@ -49,14 +53,24 @@ class NativeBackend(QObject):
         self.audio_output = None
         self.envelope = []
         self.chunk_ms = 10
+        self.mode = "input" # input|control
 
         # Get configuration values (use defaults if unavailable)
         if self.window is not None and hasattr(self.window, "core"):
             self.channels = int(self.window.core.config.get('audio.input.channels', 1))
             self.rate = int(self.window.core.config.get('audio.input.rate', 44100))
+            self.latency_ms = int(self.window.core.config.get('audio.input.latency_ms', 30))
         else:
             self.channels = 1
             self.rate = 44100
+            self.latency_ms = 30
+
+        # internal recording state flag to suppress volume updates after stop
+        # This prevents late/queued readyRead events from updating the UI when recording is no longer active.
+        self._is_recording = False
+
+        self._dtype = None
+        self._norm = None
 
     def init(self):
         """
@@ -66,6 +80,14 @@ class NativeBackend(QObject):
             self.check_audio_devices()
             self.initialized = True
 
+    def set_mode(self, mode: str):
+        """
+        Set input mode (input|control)
+
+        :param mode: mode name
+        """
+        self.mode = mode
+
     def set_repeat_callback(self, callback):
         """
         Set callback to be called on loop recording
@@ -93,14 +115,6 @@ class NativeBackend(QObject):
         """
         self.path = path
 
-    def set_bar(self, bar):
-        """
-        Set audio level bar
-
-        :param bar: audio level bar
-        """
-        self.bar = bar
-
     def start(self):
         """
         Start audio input recording
@@ -108,6 +122,7 @@ class NativeBackend(QObject):
         :return: True if started
         """
         self.init()
+
         # Clear previous frames
         self.frames = []
 
@@ -127,6 +142,11 @@ class NativeBackend(QObject):
         # Set up audio input and start recording
         self.setup_audio_input()
         self.start_time = time.time()
+
+        # mark recording as active only after setup succeeded
+        # This ensures process_audio_input() will start updating the UI.
+        if self.audio_source is not None and self.audio_io_device is not None:
+            self._is_recording = True
         return True
 
     def stop(self) -> bool:
@@ -136,9 +156,20 @@ class NativeBackend(QObject):
         :return: True if stopped
         """
         result = False
+
+        # immediately mark that we are no longer recording
+        # This blocks any late UI updates coming from queued signals.
+        self._is_recording = False
+
         if self.audio_source is not None:
             # Disconnect the readyRead signal
-            self.audio_io_device.readyRead.disconnect(self.process_audio_input)
+            try:
+                if self.audio_io_device is not None:
+                    self.audio_io_device.readyRead.disconnect(self.process_audio_input)
+            except (TypeError, RuntimeError):
+                # ignore if already disconnected or device gone ---
+                pass
+
             self.audio_source.stop()
             self.audio_source = None
             self.audio_io_device = None
@@ -149,6 +180,10 @@ class NativeBackend(QObject):
                 result = True
             else:
                 print("No audio data recorded")
+
+        # reset input volume on stop to visually indicate end of recording ---
+        self.reset_audio_level()
+
         return result
 
     def has_source(self) -> bool:
@@ -187,8 +222,7 @@ class NativeBackend(QObject):
 
     def reset_audio_level(self):
         """Reset the audio level bar"""
-        if self.bar is not None:
-            self.bar.setLevel(0)
+        self.window.controller.audio.ui.on_input_volume_change(0, self.mode)
 
     def check_audio_input(self) -> bool:
         """
@@ -197,24 +231,27 @@ class NativeBackend(QObject):
         :return: True if working
         """
         self.init()
-        from PySide6.QtMultimedia import QMediaDevices, QAudioFormat, QAudioSource
-
         devices = QMediaDevices.audioInputs()
         if not devices:
             print("No audio input devices found.")
             return False
 
         device = self.selected_device if self.selected_device else devices[0]
-        audio_format = QAudioFormat()
-        audio_format.setSampleRate(self.rate)
-        audio_format.setChannelCount(self.channels)
-        audio_format.setSampleFormat(QAudioFormat.SampleFormat.Int16)
-
-        if not device.isFormatSupported(audio_format):
-            print("Requested format not supported, using nearest format.")
-            audio_format = device.preferredFormat()
+
+        audio_format = device.preferredFormat()
+        desired = QAudioFormat()
+        desired.setSampleRate(self.rate)
+        desired.setChannelCount(self.channels)
+        desired.setSampleFormat(QAudioFormat.SampleFormat.Int16)
+        if device.isFormatSupported(desired):
+            audio_format = desired
+
         try:
             audio_source = QAudioSource(device, audio_format)
+            bs = int(audio_format.sampleRate() * audio_format.channelCount() * audio_format.bytesPerSample() * (float(self.latency_ms) / 1000.0))
+            if bs < 4096:
+                bs = 4096
+            audio_source.setBufferSize(bs)
             io_device = audio_source.start()
             if io_device is None:
                 print("Unable to access audio input device")
@@ -227,7 +264,6 @@ class NativeBackend(QObject):
 
     def check_audio_devices(self):
         """Check audio input devices"""
-        from PySide6.QtMultimedia import QMediaDevices
         self.devices = QMediaDevices.audioInputs()
         if not self.devices:
             # no devices found
@@ -274,39 +310,30 @@ class NativeBackend(QObject):
             print("No audio input device selected")
             return
 
-        from PySide6.QtMultimedia import QAudioFormat, QAudioSource
-
-        # Define audio format
-        audio_format = QAudioFormat()
-        audio_format.setSampleRate(int(self.window.core.config.get('audio.input.rate', 44100)))
-        audio_format.setChannelCount(int(self.window.core.config.get('audio.input.channels', 1)))
-        audio_format.setSampleFormat(QAudioFormat.SampleFormat.Int16)
-
-        # Select default audio input device
         audio_input_device = self.selected_device
 
-        # Check if the format is supported
-        if not audio_input_device.isFormatSupported(audio_format):
-            print("Requested format not supported, using nearest format.")
-            audio_format = audio_input_device.preferredFormat()
-            if audio_format.channelCount() > 2:
-                audio_format.setChannelCount(2)
-            if audio_format.sampleRate() > 44100:
-                audio_format.setSampleRate(44100)
-            if audio_format.bytesPerSample() > 2:
-                audio_format.setSampleFormat(QAudioFormat.SampleFormat.Int16)
-
-        # Store the actual format being used
+        audio_format = audio_input_device.preferredFormat()
+        desired = QAudioFormat()
+        desired.setSampleRate(int(self.window.core.config.get('audio.input.rate', 44100)))
+        desired.setChannelCount(int(self.window.core.config.get('audio.input.channels', 1)))
+        desired.setSampleFormat(QAudioFormat.SampleFormat.Int16)
+        if audio_input_device.isFormatSupported(desired):
+            audio_format = desired
+
         self.actual_audio_format = audio_format
+        self._dtype = self.get_dtype_from_sample_format(self.actual_audio_format.sampleFormat())
+        self._norm = self.get_normalization_factor(self.actual_audio_format.sampleFormat())
 
-        # Create QAudioSource object with the device and format
         try:
             self.audio_source = QAudioSource(audio_input_device, audio_format)
+            bs = int(audio_format.sampleRate() * audio_format.channelCount() * audio_format.bytesPerSample() * (float(self.latency_ms) / 1000.0))
+            if bs < 4096:
+                bs = 4096
+            self.audio_source.setBufferSize(bs)
         except Exception as e:
             self.disconnected = True
             print(f"Failed to create audio source: {e}")
 
-        # Start audio input and obtain the QIODevice
         try:
             self.audio_io_device = self.audio_source.start()
             if self.audio_io_device is None:
@@ -318,13 +345,13 @@ class NativeBackend(QObject):
             self.audio_io_device = None
             return
 
-        # Connect the readyRead signal to process incoming data
         self.audio_io_device.readyRead.connect(self.process_audio_input)
 
     def process_audio_input(self):
         """Process incoming audio data"""
-        import numpy as np
-        from PySide6.QtMultimedia import QAudioFormat
+        # guard against late calls after stop or missing device ---
+        if not self._is_recording or self.audio_io_device is None:
+            return
 
         # add seconds to stop timer
         data = self.audio_io_device.readAll()
@@ -339,8 +366,8 @@ class NativeBackend(QObject):
 
         # Determine the correct dtype and normalization factor
         sample_format = self.actual_audio_format.sampleFormat()
-        dtype = self.get_dtype_from_sample_format(sample_format)
-        normalization_factor = self.get_normalization_factor(sample_format)
+        dtype = self._dtype if self._dtype is not None else self.get_dtype_from_sample_format(sample_format)
+        normalization_factor = self._norm if self._norm is not None else self.get_normalization_factor(sample_format)
 
         # Convert bytes to NumPy array of the appropriate type
         samples = np.frombuffer(data_bytes, dtype=dtype)
@@ -383,8 +410,10 @@ class NativeBackend(QObject):
 
         :param level: audio level
         """
-        if self.bar is not None:
-            self.bar.setLevel(level)
+        # do not update UI if recording already stopped
+        if not self._is_recording:
+            return
+        self.window.controller.audio.ui.on_input_volume_change(int(level), self.mode)
 
     def save_audio_file(self, filename: str):
         """
@@ -392,20 +421,40 @@ class NativeBackend(QObject):
 
         :param filename: output file name
         """
-        import wave
         # Define the parameters for the WAV file
         channels = self.actual_audio_format.channelCount()
-        sample_size = self.actual_audio_format.bytesPerSample()
         frame_rate = self.actual_audio_format.sampleRate()
+        sample_format = self.actual_audio_format.sampleFormat()
+
+        raw = b''.join(self.frames)
+
+        if sample_format == QAudioFormat.SampleFormat.Int16:
+            out_bytes = raw
+            sample_size = 2
+        elif sample_format == QAudioFormat.SampleFormat.UInt8:
+            arr = np.frombuffer(raw, dtype=np.uint8).astype(np.int16)
+            arr = (arr - 128) << 8
+            out_bytes = arr.tobytes()
+            sample_size = 2
+        elif sample_format == QAudioFormat.SampleFormat.Int32:
+            arr = np.frombuffer(raw, dtype=np.int32)
+            arr = (arr >> 16).astype(np.int16)
+            out_bytes = arr.tobytes()
+            sample_size = 2
+        elif sample_format == QAudioFormat.SampleFormat.Float:
+            arr = np.frombuffer(raw, dtype=np.float32)
+            arr = np.clip(arr, -1.0, 1.0)
+            arr = (arr * 32767.0).astype(np.int16)
+            out_bytes = arr.tobytes()
+            sample_size = 2
+        else:
+            raise ValueError("Unsupported sample format")
 
-        # Open the WAV file
         wf = wave.open(filename, 'wb')
         wf.setnchannels(channels)
         wf.setsampwidth(sample_size)
         wf.setframerate(frame_rate)
-
-        # Write frames to the file
-        wf.writeframes(b''.join(self.frames))
+        wf.writeframes(out_bytes)
         wf.close()
 
     def get_dtype_from_sample_format(self, sample_format):
@@ -414,9 +463,6 @@ class NativeBackend(QObject):
 
         :param sample_format: QAudioFormat.SampleFormat
         """
-        import numpy as np
-        from PySide6.QtMultimedia import QAudioFormat
-
         if sample_format == QAudioFormat.SampleFormat.UInt8:
             return np.uint8
         elif sample_format == QAudioFormat.SampleFormat.Int16:
@@ -434,8 +480,6 @@ class NativeBackend(QObject):
 
         :param sample_format: QAudioFormat.SampleFormat
         """
-        from PySide6.QtMultimedia import QAudioFormat
-
         if sample_format == QAudioFormat.SampleFormat.UInt8:
             return 255.0
         elif sample_format == QAudioFormat.SampleFormat.Int16:
@@ -463,11 +507,6 @@ class NativeBackend(QObject):
         :param signals: Signals to emit on playback
         :return: True if started
         """
-        from PySide6.QtMultimedia import QMediaPlayer, QAudioOutput, QMediaDevices
-        from PySide6.QtCore import QUrl, QTimer
-        if signals is not None:
-            signals.playback.emit(event_name)
-
         self.audio_output = QAudioOutput()
         self.audio_output.setVolume(1.0)
 
@@ -519,6 +558,7 @@ class NativeBackend(QObject):
         self.playback_timer.start()
         self.volume_timer.start()
         signals.volume_changed.emit(0)
+        signals.playback.emit(event_name)
 
     def stop_timers(self):
         """
@@ -558,8 +598,7 @@ class NativeBackend(QObject):
         """
         if self.player is not None:
             self.player.stop()
-            if self.playback_timer is not None:
-                self.playback_timer.stop()
+        self.stop_timers()
         return False
 
     def calculate_envelope(
@@ -573,7 +612,6 @@ class NativeBackend(QObject):
         :param audio_file: Path to the audio file
         :param chunk_ms: Size of each chunk in milliseconds
         """
-        import numpy as np
         audio = AudioSegment.from_file(audio_file)
         max_amplitude = 32767
         envelope = []
@@ -611,8 +649,6 @@ class NativeBackend(QObject):
 
         :return devices list: [(id, name)]
         """
-        from bs4 import UnicodeDammit
-        from PySide6.QtMultimedia import QMediaDevices
         devices = QMediaDevices.audioInputs()
         devices_list = []
         for index, device in enumerate(devices):
@@ -626,8 +662,6 @@ class NativeBackend(QObject):
 
         :return devices list: [(id, name)]
         """
-        from bs4 import UnicodeDammit
-        from PySide6.QtMultimedia import QMediaDevices
         devices = QMediaDevices.audioOutputs()
         devices_list = []
         for index, device in enumerate(devices):
@@ -641,7 +675,6 @@ class NativeBackend(QObject):
 
         :return: (device_id, error_message) tuple
         """
-        from PySide6.QtMultimedia import QMediaDevices
         default_device = QMediaDevices.defaultAudioInput()
         devices = QMediaDevices.audioInputs()
         try:
@@ -656,11 +689,10 @@ class NativeBackend(QObject):
 
         :return: (device_id, None) if successful, (None, error_message) if failed
         """
-        from PySide6.QtMultimedia import QMediaDevices
         default_device = QMediaDevices.defaultAudioOutput()
         devices = QMediaDevices.audioOutputs()
         try:
             index = devices.index(default_device)
         except ValueError:
             index = None
-        return index, None
+        return index, None

pygpt_net/core/audio/backend/pyaudio.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.07 03:00:00                  #
+# Updated Date: 2025.08.27 07:00:00                  #
 # ================================================== #
 
 import time
@@ -27,7 +27,6 @@ class PyaudioBackend:
         self.window = window
         self.path = None
         self.frames = []
-        self.bar = None
         self.loop = False
         self.stop_callback = None
         self.start_time = 0
@@ -36,6 +35,7 @@ class PyaudioBackend:
         self.pyaudio_instance_output = None
         self.stream = None
         self.stream_output = None
+        self.mode = "input"  # input|control
 
         # Get configuration values (use defaults if unavailable)
         if self.window is not None and hasattr(self.window, "core"):
@@ -60,6 +60,14 @@ class PyaudioBackend:
             self.check_audio_devices()
             self.initialized = True
 
+    def set_mode(self, mode: str):
+        """
+        Set input mode (input|control)
+
+        :param mode: mode name
+        """
+        self.mode = mode
+
     def set_repeat_callback(self, callback):
         """
         Set callback to be called on loop recording.
@@ -87,14 +95,6 @@ class PyaudioBackend:
         """
         self.path = path
 
-    def set_bar(self, bar):
-        """
-        Set audio level bar.
-
-        :param bar: audio level bar widget to update with audio levels
-        """
-        self.bar = bar
-
     def start(self):
         """
         Start audio input recording using PyAudio.
@@ -169,8 +169,7 @@ class PyaudioBackend:
         """
         Reset the audio level bar.
         """
-        if self.bar is not None:
-            self.bar.setLevel(0)
+        self.window.controller.audio.ui.on_input_volume_change(0, self.mode)
 
     def check_audio_input(self) -> bool:
         """
@@ -284,11 +283,10 @@ class PyaudioBackend:
         level_percent = int(level * 100)
 
         # Update the audio level bar if available.
-        if self.bar is not None:
-            try:
-                QTimer.singleShot(0, lambda: self.bar.setLevel(level_percent))
-            except Exception:
-                pass
+        try:
+            QTimer.singleShot(0, lambda: self.window.controller.audio.ui.on_input_volume_change(level_percent, self.mode))
+        except Exception:
+            pass
 
         # Handle loop recording if enabled.
         if self.loop and self.stop_callback is not None:
@@ -306,8 +304,7 @@ class PyaudioBackend:
         Update the audio level bar.
         :param level: audio level (0-100).
         """
-        if self.bar is not None:
-            self.bar.setLevel(level)
+        self.window.controller.audio.ui.on_input_volume_change(level, self.mode)
 
     def save_audio_file(self, filename: str):
         """

pygpt_net/core/audio/backend/pygame.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.07 03:00:00                  #
+# Updated Date: 2025.08.27 07:00:00                  #
 # ================================================== #
 
 import time
@@ -26,7 +26,6 @@ class PygameBackend:
         self.window = window
         self.path = None
         self.frames = []      # List to store captured audio chunks (bytes)
-        self.bar = None       # Optional audio level bar widget
         self.loop = False
         self.stop_callback = None
         self.start_time = 0
@@ -54,6 +53,7 @@ class PygameBackend:
         self.devices = []
         self.selected_device = None
         self.initialized = False
+        self.mode = "input"  # input|control
 
     def init(self):
         """
@@ -75,6 +75,14 @@ class PygameBackend:
             self.check_audio_devices()
             self.initialized = True
 
+    def set_mode(self, mode: str):
+        """
+        Set input mode (input|control)
+
+        :param mode: mode name
+        """
+        self.mode = mode
+
     def set_repeat_callback(self, callback):
         """
         Set a callback to be called on loop recording.
@@ -102,15 +110,6 @@ class PygameBackend:
         """
         self.path = path
 
-    def set_bar(self, bar):
-        """
-        Set an audio level bar widget.
-        If not available, this will be silently ignored.
-
-        :param bar: A widget that has a setLevel method to update the audio level.
-        """
-        self.bar = bar
-
     def start(self):
         """
         Start audio recording using pygame’s SDL2 audio capture.
@@ -187,8 +186,7 @@ class PygameBackend:
         """
         Reset the audio level bar (if available).
         """
-        if self.bar is not None:
-            self.bar.setLevel(0)
+        self.window.controller.audio.ui.on_input_volume_change(0, self.mode)
 
     def check_audio_input(self) -> bool:
         """
@@ -312,8 +310,7 @@ class PygameBackend:
         level = min(max(rms, 0.0), 1.0)
         level_percent = int(level * 100)
 
-        if self.bar is not None:
-            QTimer.singleShot(0, lambda: self.bar.setLevel(level_percent))
+        QTimer.singleShot(0, lambda: self.window.controller.audio.ui.on_input_volume_change(level_percent, self.mode))
 
         # Handle loop recording if enabled.
         if self.loop and self.stop_callback is not None:

pygpt_net/core/audio/capture.py

@@ -6,8 +6,9 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.07 03:00:00                  #
+# Updated Date: 2025.08.27 07:00:00                  #
 # ================================================== #
+
 from typing import List, Tuple
 
 from .backend.native import NativeBackend
@@ -57,6 +58,14 @@ class Capture:
         """
         self.get_backend().set_repeat_callback(callback)
 
+    def set_mode(self, mode: str):
+        """
+        Set input mode (input|control)
+
+        :param mode: mode name
+        """
+        self.get_backend().set_mode(mode)
+
     def set_loop(self, loop: bool):
         """
         Set loop recording
@@ -73,14 +82,6 @@ class Capture:
         """
         self.get_backend().set_path(path)
 
-    def set_bar(self, bar):
-        """
-        Set audio level bar
-
-        :param bar: audio level bar
-        """
-        self.get_backend().set_bar(bar)
-
     def start(self):
         """
         Start audio input recording

pygpt_net/core/audio/context.py

@@ -6,12 +6,10 @@
 # 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.08.27 07:00:00                  #
 # ================================================== #
 
-from typing import Dict, Any
-
-from pygpt_net.item.ctx import CtxItem
+from typing import Dict
 
 
 class AudioContext:
@@ -35,5 +33,4 @@ class AudioContext:
             "prev_id": self.prev_id
         }
         # sort by keys
-        data = dict(sorted(data.items(), key=lambda item: item[0]))
-        return data
+        return dict(sorted(data.items(), key=lambda item: item[0]))

pygpt_net/core/command/command.py

@@ -525,6 +525,8 @@ class Command:
                 "bool": "boolean",
                 "dict": "object",
                 "list": "array",
+                "float": "number",
+                "any": "string",
             }
 
             limit = self.DESC_LIMIT