openvoiceui 1.0.0

package/providers/stt/whisper_provider.py

@@ -0,0 +1,100 @@
+"""
+Local Whisper STT provider (faster-whisper).
+
+Ref: future-dev-plans/02-PROVIDER-SYSTEMS.md (WhisperProvider section)
+Server-side transcription via local faster-whisper model.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+import time
+from typing import Any, Dict, List, Optional
+
+from providers.stt.base import STTError, STTProvider, TranscriptionResult
+from providers.registry import ProviderType, registry
+
+logger = logging.getLogger(__name__)
+
+
+class WhisperProvider(STTProvider):
+    """Local Whisper model for server-side transcription via faster-whisper."""
+
+    def __init__(self, config: Dict[str, Any] = None) -> None:
+        super().__init__(config)
+        self.model_size = self._config.get("model", "base")
+        self.device = self._config.get("device", "cpu")
+        self._model = None
+
+    def _load_model(self):
+        if self._model is None:
+            try:
+                from faster_whisper import WhisperModel  # type: ignore
+                self._model = WhisperModel(self.model_size, device=self.device)
+                logger.info("Whisper model loaded: %s on %s", self.model_size, self.device)
+            except ImportError:
+                raise STTError(
+                    "whisper",
+                    "faster-whisper not installed: pip install faster-whisper",
+                )
+            except Exception as exc:
+                raise STTError("whisper", f"Failed to load model: {exc}") from exc
+        return self._model
+
+    def transcribe(
+        self,
+        audio_data: bytes,
+        language: Optional[str] = None,
+        **kwargs,
+    ) -> TranscriptionResult:
+        start = time.time()
+        try:
+            model = self._load_model()
+        except STTError:
+            raise
+
+        # Write to temp WAV file
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            f.write(audio_data)
+            temp_path = f.name
+
+        try:
+            segments, info = model.transcribe(temp_path, language=language or "en")
+            text = " ".join(seg.text.strip() for seg in segments)
+        except Exception as exc:
+            raise STTError("whisper", f"Transcription failed: {exc}") from exc
+        finally:
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+
+        return TranscriptionResult(
+            text=text,
+            confidence=0.9,
+            language=info.language,
+            duration_ms=(time.time() - start) * 1000,
+            provider="whisper",
+        )
+
+    def is_available(self) -> bool:
+        try:
+            from faster_whisper import WhisperModel  # type: ignore  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    def get_info(self) -> Dict[str, Any]:
+        return {
+            "name": self._config.get("name", "Whisper Local"),
+            "status": "active" if self.is_available() else "inactive",
+            "model": self.model_size,
+            "device": self.device,
+            "available": self.is_available(),
+        }
+
+
+# Auto-register when this module is imported
+registry.register(ProviderType.STT, "whisper", WhisperProvider)

package/providers/tts/__init__.py

@@ -0,0 +1,20 @@
+"""TTS provider package — adapter layer.
+
+Architecture note:
+  - tts_providers/  ← canonical implementation (add new providers here)
+  - providers/tts/  ← adapter wrappers used by the registry system and tests
+                       These delegate to tts_providers/ for actual TTS work.
+
+To add a new TTS provider:
+  1. Create tts_providers/myprovider_provider.py  (inheriting TTSProvider from tts_providers/base_provider.py)
+  2. Register it in tts_providers/__init__.py _PROVIDERS dict
+  3. Add metadata to tts_providers/providers_config.json
+"""
+
+from providers.tts.base import TTSProvider, TTSVoice, TTSError, TTSVoiceNotFoundError
+
+# Import concrete providers so their registry.register() calls fire
+from providers.tts import supertonic_provider  # noqa: F401
+from providers.tts import groq_provider  # noqa: F401
+
+__all__ = ["TTSProvider", "TTSVoice", "TTSError", "TTSVoiceNotFoundError"]

package/providers/tts/base.py

@@ -0,0 +1,91 @@
+"""
+TTS provider abstract base class.
+
+Extends the existing tts_providers/base_provider.py pattern to conform to the
+unified BaseProvider interface required by ADR-003.
+"""
+
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from providers.base import BaseProvider, ProviderError
+
+
+@dataclass
+class TTSVoice:
+    id: str
+    name: str
+    language: str = "en"
+    gender: Optional[str] = None
+    description: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "language": self.language,
+            "gender": self.gender,
+            "description": self.description,
+        }
+
+
+class TTSProvider(BaseProvider):
+    """Abstract base class for TTS providers (Supertonic, Groq, ElevenLabs, etc.)."""
+
+    @abstractmethod
+    def generate_speech(self, text: str, **kwargs) -> bytes:
+        """Convert text to audio bytes (WAV or MP3)."""
+        pass
+
+    @abstractmethod
+    def list_voices(self) -> List[str]:
+        """Return list of available voice IDs."""
+        pass
+
+    def list_voices_detailed(self) -> List[TTSVoice]:
+        """Return TTSVoice objects; override for richer metadata."""
+        return [TTSVoice(id=v, name=v) for v in self.list_voices()]
+
+    def get_default_voice(self) -> Optional[str]:
+        voices = self.list_voices()
+        return voices[0] if voices else None
+
+    def validate_text(self, text: str) -> None:
+        if text is None:
+            raise ValueError("Text cannot be None")
+        if not isinstance(text, str):
+            raise ValueError(f"Text must be str, got {type(text).__name__}")
+        if not text.strip():
+            raise ValueError("Text cannot be empty or whitespace-only")
+
+    def validate_voice(self, voice: str) -> bool:
+        return voice in self.list_voices()
+
+    def is_available(self) -> bool:
+        return self.get_info().get("status", "inactive") == "active"
+
+    def get_info(self) -> Dict[str, Any]:
+        return {
+            "name": self._config.get("name", self.__class__.__name__),
+            "status": "active",
+            "available": True,
+        }
+
+
+class TTSError(ProviderError):
+    """TTS-specific provider error."""
+    pass
+
+
+class TTSVoiceNotFoundError(TTSError):
+    """Requested voice does not exist in this provider."""
+    pass
+
+
+__all__ = [
+    "TTSProvider",
+    "TTSVoice",
+    "TTSError",
+    "TTSVoiceNotFoundError",
+]

package/providers/tts/groq_provider.py

@@ -0,0 +1,74 @@
+"""
+Groq Orpheus TTS provider.
+
+Ref: future-dev-plans/02-PROVIDER-SYSTEMS.md (GroqProvider section)
+Fallback TTS when Supertonic is unavailable.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, List
+
+from providers.tts.base import TTSError, TTSProvider
+from providers.registry import ProviderType, registry
+
+logger = logging.getLogger(__name__)
+
+
+class GroqTTSProvider(TTSProvider):
+    """Groq Orpheus cloud TTS provider."""
+
+    def __init__(self, config: Dict[str, Any] = None) -> None:
+        super().__init__(config)
+        self.api_key = self._resolve_api_key()
+        self.model = self._config.get("model", "canopylabs/orpheus-v1-english")
+        self.default_voice = self._config.get("voice", "autumn")
+
+    def _resolve_api_key(self) -> str:
+        key = self._config.get("api_key", "")
+        if key and not key.startswith("${"):
+            return key
+        return os.getenv("GROQ_API_KEY", "")
+
+    def generate_speech(self, text: str, **kwargs) -> bytes:
+        self.validate_text(text)
+        if not self.api_key:
+            raise TTSError("groq", "GROQ_API_KEY not set")
+
+        try:
+            import groq as groq_lib  # type: ignore
+        except ImportError:
+            raise TTSError("groq", "groq library not installed: pip install groq")
+
+        voice = kwargs.get("voice", self.default_voice)
+        try:
+            client = groq_lib.Groq(api_key=self.api_key)
+            response = client.audio.speech.create(
+                model=self.model,
+                voice=voice,
+                input=text,
+                response_format="mp3",
+            )
+            return response.read()
+        except Exception as exc:
+            raise TTSError("groq", f"Generation failed: {exc}") from exc
+
+    def list_voices(self) -> List[str]:
+        return ["autumn", "diana", "hannah", "austin", "daniel", "troy"]
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def get_info(self) -> Dict[str, Any]:
+        return {
+            "name": self._config.get("name", "Groq Orpheus"),
+            "status": "active" if self.is_available() else "inactive",
+            "model": self.model,
+            "available": self.is_available(),
+        }
+
+
+# Auto-register when this module is imported
+registry.register(ProviderType.TTS, "groq", GroqTTSProvider)

package/providers/tts/supertonic_provider.py

@@ -0,0 +1,72 @@
+"""
+Supertonic ONNX TTS provider wrapper.
+
+Wraps the existing tts_providers/supertonic_provider.py to conform to the
+unified providers.tts.base.TTSProvider interface (ADR-003).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+from providers.tts.base import TTSError, TTSProvider
+from providers.registry import ProviderType, registry
+
+logger = logging.getLogger(__name__)
+
+
+class SupertonicProvider(TTSProvider):
+    """Supertonic local ONNX TTS provider."""
+
+    def __init__(self, config: Dict[str, Any] = None) -> None:
+        super().__init__(config)
+        import os
+        self.onnx_dir = self._config.get("onnx_dir", os.environ.get("SUPERTONIC_ONNX_DIR", os.path.expanduser("~/supertonic/assets/onnx")))
+        self.default_voice = self._config.get("default_voice", "M1")
+        self._delegate = None
+
+    def _get_delegate(self):
+        """Lazy-load the underlying provider to avoid import-time crashes."""
+        if self._delegate is None:
+            try:
+                from tts_providers.supertonic_provider import SupertonicProvider as _Impl  # type: ignore
+                self._delegate = _Impl()
+            except Exception as exc:
+                raise TTSError("supertonic", f"Failed to load Supertonic: {exc}") from exc
+        return self._delegate
+
+    def generate_speech(self, text: str, **kwargs) -> bytes:
+        self.validate_text(text)
+        voice = kwargs.get("voice", self.default_voice)
+        try:
+            return self._get_delegate().generate_speech(text, voice=voice, **kwargs)
+        except Exception as exc:
+            raise TTSError("supertonic", f"Generation failed: {exc}") from exc
+
+    def list_voices(self) -> List[str]:
+        try:
+            return self._get_delegate().list_voices()
+        except Exception:
+            return [self.default_voice]
+
+    def is_available(self) -> bool:
+        try:
+            from tts_providers.supertonic_provider import SupertonicProvider as _Impl  # type: ignore
+            instance = _Impl()
+            return instance.is_available()
+        except Exception:
+            return False
+
+    def get_info(self) -> Dict[str, Any]:
+        return {
+            "name": self._config.get("name", "Supertonic ONNX"),
+            "status": "active" if self.is_available() else "inactive",
+            "onnx_dir": self.onnx_dir,
+            "default_voice": self.default_voice,
+            "available": self.is_available(),
+        }
+
+
+# Auto-register when this module is imported
+registry.register(ProviderType.TTS, "supertonic", SupertonicProvider)

package/requirements.txt

@@ -0,0 +1,38 @@
+# Python 3.10+ required
+# Core framework
+Flask==3.1.3
+flask-cors==6.0.2
+flask-limiter==4.1.1
+flask-sock==0.7.0
+
+# WebSocket & HTTP
+websockets==16.0
+requests==2.32.5
+
+# Environment & config
+python-dotenv==1.2.1
+
+# System monitoring
+psutil==7.2.2
+
+# Speech-to-text (Faster Whisper — optional, for local STT)
+faster-whisper==1.2.1
+
+# TTS providers
+groq==1.0.0                 # Groq Orpheus TTS (required if using groq provider)
+
+# Auth (Clerk JWT — optional, only if CANVAS_REQUIRE_AUTH=true)
+PyJWT==2.11.0
+cryptography==46.0.5
+
+# Face recognition (local, free — runs on-server, no API calls)
+deepface>=0.0.93            # DeepFace biometric face recognition
+tf-keras>=2.19.0            # Required by deepface (Keras backend)
+
+# AI providers (optional)
+google-generativeai==0.8.6  # Only if using Gemini
+
+# Supertonic local TTS (optional — install manually if using local ONNX TTS)
+# onnxruntime>=1.23.1
+# soundfile>=0.12.1
+# librosa>=0.10.0

package/routes/__init__.py

@@ -0,0 +1,10 @@
+# routes package — Flask Blueprints for ai-eyes2 (Phase 2 refactor)
+
+import os
+from pathlib import Path
+
+# Base directory for all persistent data (uploads, music, faces, etc.).
+# Default: app root (backward-compatible with non-Docker installs).
+# Docker sets DATA_DIR=/app/data via docker-compose environment.
+APP_ROOT = Path(__file__).parent.parent
+DATA_DIR = Path(os.getenv('DATA_DIR', str(APP_ROOT)))