Development (#14)

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

Author: BBC-Esq

config/manager.py

@@ -1,17 +1,15 @@
-"""
-Centralized configuration management for the Whisper transcriber.
-"""
 from __future__ import annotations
 
-import logging
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 import yaml
 
 from utils import get_resource_path
+from core.logging_config import get_logger
+from core.exceptions import ConfigurationError
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ConfigManager:
@@ -25,7 +23,8 @@ class ConfigManager:
         "supported_quantizations": {
             "cpu": [],
             "cuda": []
-        }
+        },
+        "curate_transcription": True
     }
 
     def __init__(self):
@@ -51,6 +50,9 @@ def _load_from_file(self) -> Dict[str, Any]:
         except yaml.YAMLError as e:
             logger.error(f"Error parsing config file: {e}")
             config = {}
+        except Exception as e:
+            logger.error(f"Unexpected error loading config: {e}")
+            config = {}
 
         merged_config = self.DEFAULT_CONFIG.copy()
         self._deep_update(merged_config, config)
@@ -68,7 +70,7 @@ def save_config(self, config: Dict[str, Any]) -> None:
 
         except Exception as e:
             logger.error(f"Failed to save configuration: {e}")
-            raise
+            raise ConfigurationError(f"Failed to save configuration: {e}") from e
 
     def update_config(self, updates: Dict[str, Any]) -> None:
         config = self.load_config()

core/audio/manager.py

@@ -1,15 +1,22 @@
-# core/audio/manager.py
+from __future__ import annotations
+
 from typing import Optional
-from pathlib import Path
-import tempfile
 import wave
+
 from PySide6.QtCore import QObject, Signal, Slot
-from .recording import RecordingThread
+
+from core.audio.recording import RecordingThread
+from core.temp_file_manager import temp_file_manager
+from core.logging_config import get_logger
+from core.exceptions import AudioSaveError
+
+logger = get_logger(__name__)
+
 
 class AudioManager(QObject):
     recording_started = Signal()
     recording_stopped = Signal()
-    audio_ready = Signal(str)  # file path
+    audio_ready = Signal(str)
     audio_error = Signal(str)
 
     def __init__(self, samplerate: int = 44_100, channels: int = 1, dtype: str = "int16"):
@@ -18,55 +25,89 @@ def __init__(self, samplerate: int = 44_100, channels: int = 1, dtype: str = "in
         self.channels = channels
         self.dtype = dtype
         self._recording_thread: Optional[RecordingThread] = None
+        self._current_temp_file: Optional[str] = None
 
     def start_recording(self) -> bool:
-        """Start audio recording."""
         if self._recording_thread and self._recording_thread.isRunning():
+            logger.warning("Attempted to start recording while already recording")
+            return False
+        
+        try:
+            self._recording_thread = RecordingThread(
+                self.samplerate, self.channels, self.dtype
+            )
+            self._recording_thread.recording_error.connect(self._on_recording_error)
+            self._recording_thread.recording_finished.connect(self._on_recording_finished)
+            self._recording_thread.start()
+            self.recording_started.emit()
+            logger.info("Recording started")
+            return True
+        except Exception as e:
+            logger.exception("Failed to start recording")
+            self.audio_error.emit(f"Failed to start recording: {e}")
             return False
-            
-        self._recording_thread = RecordingThread(
-            self.samplerate, self.channels, self.dtype
-        )
-        self._recording_thread.recording_error.connect(self.audio_error)
-        self._recording_thread.recording_finished.connect(self._on_recording_finished)
-        self._recording_thread.start()
-        self.recording_started.emit()
-        return True
 
     def stop_recording(self) -> None:
-        """Stop audio recording."""
         if self._recording_thread and self._recording_thread.isRunning():
             self._recording_thread.stop()
+            logger.info("Recording stop requested")
             self.recording_stopped.emit()
 
+    @Slot(str)
+    def _on_recording_error(self, error: str) -> None:
+        logger.error(f"Recording error: {error}")
+        self.audio_error.emit(error)
+    
     @Slot()
     def _on_recording_finished(self) -> None:
-        """Handle recording completion and save to file."""
         try:
-            audio_file = self._save_recording_to_file()
+            if self._recording_thread is None:
+                raise AudioSaveError("No recording thread available")
+            
+            buffer_contents = self._recording_thread.get_buffer_contents()
+            if not buffer_contents:
+                raise AudioSaveError("No audio data recorded")
+            
+            audio_file = self._save_recording_to_file(buffer_contents)
+            self._current_temp_file = str(audio_file)
+            logger.info(f"Audio saved to: {audio_file}")
             self.audio_ready.emit(str(audio_file))
+            
+        except AudioSaveError as e:
+            logger.error(f"Audio save error: {e}")
+            self.audio_error.emit(str(e))
         except Exception as e:
+            logger.exception("Unexpected error saving audio")
             self.audio_error.emit(f"Failed to save audio: {e}")
 
-    def _save_recording_to_file(self) -> Path:
-        """Save recorded audio to temporary WAV file."""
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tf:
-            path = Path(tf.name)
-        
-        with wave.open(str(path), "wb") as wf:
-            wf.setnchannels(self.channels)
-            wf.setsampwidth(self._sample_width())
-            wf.setframerate(self.samplerate)
-            while not self._recording_thread.buffer.empty():
-                wf.writeframes(self._recording_thread.buffer.get().tobytes())
+    def _save_recording_to_file(self, buffer_contents: list):
+        path = temp_file_manager.create_temp_wav()
 
-        return path
+        try:
+            with wave.open(str(path), "wb") as wf:
+                wf.setnchannels(self.channels)
+                wf.setsampwidth(self._sample_width())
+                wf.setframerate(self.samplerate)
+                for chunk in buffer_contents:
+                    wf.writeframes(chunk.tobytes())
+            return path
+        except Exception as e:
+            temp_file_manager.release(path)
+            raise AudioSaveError(f"Failed to write WAV file: {e}") from e
 
     def _sample_width(self) -> int:
         return {"int16": 2, "int32": 4, "float32": 4}.get(self.dtype, 2)
 
     def cleanup(self) -> None:
-        """Clean up audio resources."""
         if self._recording_thread and self._recording_thread.isRunning():
             self._recording_thread.stop()
-            self._recording_thread.wait()
+            self._recording_thread.wait(5000)
+            if self._recording_thread.isRunning():
+                logger.warning("Recording thread did not stop in time")
+                self._recording_thread.terminate()
+        
+        if self._current_temp_file:
+            temp_file_manager.release(self._current_temp_file)
+            self._current_temp_file = None
+        
+        logger.debug("AudioManager cleanup complete")

core/audio/recording.py

@@ -1,24 +1,17 @@
-"""
-Audio-capture thread and tiny WAV helpers.
-
-Placed in: myapp/core/audio/recording.py
-"""
 from __future__ import annotations
 
-import logging
 import queue
-import tempfile
 import threading
-import wave
 from contextlib import contextmanager
-from pathlib import Path
 from typing import Iterator
 
 import sounddevice as sd
 from PySide6.QtCore import QThread, Signal
 
+from core.logging_config import get_logger
+from core.exceptions import AudioRecordingError
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class RecordingThread(QThread):
@@ -33,35 +26,53 @@ def __init__(self, samplerate: int = 44_100, channels: int = 1, dtype: str = "in
         self.channels = channels
         self.dtype = dtype
         self.buffer: queue.Queue = queue.Queue()
+        self._stream_error: str | None = None
 
     @contextmanager
     def _audio_stream(self) -> Iterator[None]:
-        stream = sd.InputStream(
-            samplerate=self.samplerate,
-            channels=self.channels,
-            dtype=self.dtype,
-            callback=self._audio_callback,
-        )
+        stream = None
         try:
+            stream = sd.InputStream(
+                samplerate=self.samplerate,
+                channels=self.channels,
+                dtype=self.dtype,
+                callback=self._audio_callback,
+            )
             with stream:
                 yield
+        except sd.PortAudioError as e:
+            logger.error(f"Audio device error: {e}")
+            raise AudioRecordingError(f"Audio device error: {e}") from e
+        except Exception as e:
+            logger.error(f"Failed to create audio stream: {e}")
+            raise AudioRecordingError(f"Failed to create audio stream: {e}") from e
         finally:
-            stream.close()
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception as e:
+                    logger.warning(f"Error closing audio stream: {e}")
 
-    def _audio_callback(self, indata, frames, timestamp, status) -> None:  # noqa: D401, N802
+    def _audio_callback(self, indata, frames, timestamp, status) -> None:
         if status:
-            logger.warning(status)
+            logger.warning(f"Audio callback status: {status}")
+            self._stream_error = str(status)
         self.buffer.put(indata.copy())
 
-    def run(self) -> None:  # noqa: D401
+    def run(self) -> None:
         self.update_status_signal.emit("Recording.")
         try:
             with self._audio_stream():
                 gate = threading.Event()
                 while not self.isInterruptionRequested():
-                    gate.wait(timeout=1.0)
-        except Exception as exc:  # pragma: no cover
-            self.recording_error.emit(f"Recording error: {exc}")
+                    gate.wait(timeout=0.1)
+                    if self._stream_error:
+                        logger.warning(f"Stream error during recording: {self._stream_error}")
+        except AudioRecordingError as e:
+            self.recording_error.emit(str(e))
+        except Exception as e:
+            logger.exception("Unexpected recording error")
+            self.recording_error.emit(f"Recording error: {e}")
         finally:
             self.recording_finished.emit()
 
@@ -72,20 +83,18 @@ def stop(self) -> None:
     def _sample_width_from_dtype(dtype: str) -> int:
         return {"int16": 2, "int32": 4, "float32": 4}.get(dtype, 2)
 
-    def dump_to_wav(self, outfile: str | Path) -> Path:
-
-        outfile = Path(outfile)
-        with wave.open(str(outfile), "wb") as wf:
-            wf.setnchannels(self.channels)
-            wf.setsampwidth(self._sample_width_from_dtype(self.dtype))
-            wf.setframerate(self.samplerate)
-
-            while not self.buffer.empty():
-                wf.writeframes(self.buffer.get().tobytes())
-        return outfile
-
-    def dump_to_temp_wav(self) -> Path:
-
-        tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
-        tmp.close()
-        return self.dump_to_wav(tmp.name)
+    def get_buffer_contents(self) -> list:
+        contents = []
+        while not self.buffer.empty():
+            try:
+                contents.append(self.buffer.get_nowait())
+            except queue.Empty:
+                break
+        return contents
+
+    def clear_buffer(self) -> None:
+        while not self.buffer.empty():
+            try:
+                self.buffer.get_nowait()
+            except queue.Empty:
+                break