"cleanup-old-modules"

src/reachy_mini_ha_voice/app.py

@@ -1,282 +0,0 @@
-"""
-Main application for Reachy Mini Home Assistant Voice Assistant
-"""
-
-import asyncio
-import logging
-import threading
-from typing import Optional
-
-from reachy_mini import ReachyMini, ReachyMiniApp
-
-from .config.manager import ConfigManager
-from .audio.adapter import MicrophoneArray, Speaker
-from .audio.processor import AudioProcessor
-from .voice.detector import WakeWordDetector, load_wake_word_detector
-from .motion.controller import MotionController, ReachyMiniMotionController, MockMotionController
-from .motion.queue import MotionQueue, MotionPriority
-from .esphome.server import ESPHomeServer, VoiceSatelliteProtocol
-
-logger = logging.getLogger(__name__)
-
-
-class ServerState:
-    """Global server state"""
-    
-    def __init__(self, name: str):
-        self.name = name
-        self.config = None
-        self.microphone = None
-        self.speaker = None
-        self.audio_processor = None
-        self.wake_word_detector = None
-        self.motion_controller = None
-        self.motion_queue = None
-        self.esphome_server = None
-        self.voice_satellite = None
-        self._is_running = False
-    
-    async def initialize(self, config: ConfigManager):
-        """Initialize all components"""
-        self.config = config
-        
-        # Initialize audio
-        self.microphone = MicrophoneArray(
-            sample_rate=config.get("audio.sample_rate", 16000),
-            channels=config.get("audio.channels", 1)
-        )
-        self.speaker = Speaker(
-            sample_rate=config.get("audio.sample_rate", 16000)
-        )
-        
-        # Initialize audio processor
-        self.audio_processor = AudioProcessor(
-            sample_rate=config.get("audio.sample_rate", 16000),
-            channels=config.get("audio.channels", 1),
-            block_size=config.get("audio.block_size", 1024)
-        )
-        
-        # Initialize wake word detector
-        wake_word_model = config.get("voice.wake_word", "okay_nabu")
-        self.wake_word_detector = await load_wake_word_detector(
-            f"wakewords/{wake_word_model}.tflite",
-            detector_type="micro"
-        )
-        
-        # Initialize motion controller
-        robot_host = config.get("robot.host", "localhost")
-        if robot_host == "mock":
-            self.motion_controller = MockMotionController()
-        else:
-            self.motion_controller = ReachyMiniMotionController()
-        
-        await self.motion_controller.connect(robot_host)
-        await self.motion_controller.wake_up()
-        
-        # Initialize motion queue
-        self.motion_queue = MotionQueue()
-        await self.motion_queue.start()
-        
-        # Initialize ESPHome server
-        esphome_host = config.get("esphome.host", "0.0.0.0")
-        esphome_port = config.get("esphome.port", 6053)
-        self.esphome_server = ESPHomeServer(esphome_host, esphome_port)
-        
-        # Initialize voice satellite protocol
-        self.voice_satellite = VoiceSatelliteProtocol(self)
-        
-        logger.info("Server state initialized")
-    
-    async def cleanup(self):
-        """Cleanup all components"""
-        if self.microphone:
-            await self.microphone.stop_recording()
-        
-        if self.motion_controller:
-            await self.motion_controller.stop_speech_reactive_motion()
-            await self.motion_controller.turn_off()
-            await self.motion_controller.disconnect()
-        
-        if self.motion_queue:
-            await self.motion_queue.stop()
-        
-        if self.esphome_server:
-            await self.esphome_server.stop()
-        
-        logger.info("Server state cleaned up")
-
-
-class ReachyMiniVoiceApp(ReachyMiniApp):
-    """Main application class for Reachy Mini Home Assistant Voice Assistant"""
-    
-    custom_app_url: Optional[str] = None  # Optional custom UI URL
-    
-    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
-        """
-        Main entry point for the application
-        
-        Args:
-            reachy_mini: Reachy Mini instance (already initialized and connected)
-            stop_event: Threading event to signal graceful shutdown
-        """
-        logger.info("Starting Reachy Mini Home Assistant Voice Assistant")
-        
-        # Initialize configuration
-        config = ConfigManager("config.json")
-        
-        # Create event loop for async operations
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        
-        # Create application instance
-        app = ReachyMiniVoiceApp(
-            name="Reachy Mini",
-            config=config,
-            robot_host="localhost",
-            wireless=False
-        )
-        
-        # Initialize state
-        try:
-            loop.run_until_complete(app.state.initialize(config))
-            
-            # Setup callbacks
-            app._setup_callbacks()
-            
-            # Start audio recording
-            loop.run_until_complete(app.state.microphone.start_recording(
-                None,
-                app._audio_callback,
-                sample_rate=16000,
-                channels=1,
-                block_size=1024
-            ))
-            
-            # Start ESPHome server
-            loop.run_until_complete(app.state.esphome_server.start())
-            
-            # Register mDNS discovery
-            loop.run_until_complete(app._register_mdns())
-            
-            logger.info("Application started successfully")
-            
-            # Main loop - check stop_event periodically
-            while not stop_event.is_set():
-                try:
-                    loop.run_until_complete(asyncio.sleep(1))
-                except Exception as e:
-                    logger.error(f"Error in main loop: {e}", exc_info=True)
-                    break
-            
-        except Exception as e:
-            logger.error(f"Error starting application: {e}", exc_info=True)
-        finally:
-            # Cleanup
-            logger.info("Shutting down application...")
-            loop.run_until_complete(app.state.cleanup())
-            loop.close()
-            logger.info("Application stopped")
-    
-    def _setup_callbacks(self):
-        """Setup callbacks for audio processing"""
-        # Add wake word callback
-        self.state.audio_processor.add_wake_word_callback(self._on_audio_chunk)
-        
-        # Add stream callback
-        self.state.audio_processor.add_stream_callback(self._on_stream_audio)
-    
-    async def _audio_callback(self, audio_chunk: bytes):
-        """Callback for audio recording"""
-        # Process audio chunk
-        await self.state.audio_processor.process_audio_chunk(audio_chunk)
-    
-    async def _on_audio_chunk(self, audio_chunk: bytes):
-        """Handle audio chunk for wake word detection"""
-        if self.state.wake_word_detector:
-            detected = await self.state.wake_word_detector.process_audio(audio_chunk)
-            if detected:
-                await self._on_wake_word_detected()
-    
-    async def _on_stream_audio(self, audio_chunk: bytes):
-        """Handle audio chunk for streaming to Home Assistant"""
-        if self.state.voice_satellite:
-            await self.state.voice_satellite.handle_audio(audio_chunk)
-    
-    async def _on_wake_word_detected(self):
-        """Handle wake word detection"""
-        logger.info("Wake word detected!")
-        
-        # Nod to acknowledge
-        if self.state.motion_controller:
-            await self.state.motion_controller.nod(count=1, duration=0.3)
-        
-        # Trigger voice satellite
-        if self.state.voice_satellite:
-            await self.state.voice_satellite.handle_wake_word()
-    
-    async def _register_mdns(self):
-        """Register mDNS service discovery"""
-        try:
-            from zeroconf import ServiceInfo, Zeroconf
-            
-            info = ServiceInfo(
-                "_esphomelib._tcp.local.",
-                f"{self.state.name}._esphomelib._tcp.local.",
-                addresses=[],
-                port=6053,
-                properties={
-                    "version": "1.0",
-                    "name": self.state.name,
-                    "platform": "reachy_mini"
-                }
-            )
-            
-            zeroconf = Zeroconf()
-            zeroconf.register_service(info)
-            
-            logger.info(f"Registered mDNS service: {self.state.name}")
-        except ImportError:
-            logger.warning("zeroconf not installed, mDNS discovery not available")
-        except Exception as e:
-            logger.error(f"Failed to register mDNS service: {e}")
-    
-    async def handle_tts_audio(self, audio_data: bytes):
-        """Handle TTS audio from Home Assistant"""
-        logger.info("Received TTS audio from Home Assistant")
-        
-        # Play audio
-        if self.state.speaker:
-            await self.state.speaker.play_audio(
-                audio_data,
-                None,
-                sample_rate=16000,
-                channels=1
-            )
-    
-    async def handle_stt_result(self, text: str):
-        """Handle STT result from Home Assistant"""
-        logger.info(f"Received STT result: {text}")
-        
-        # Process text (add custom logic here)
-        if "你好" in text or "hello" in text.lower():
-            await self._say_hello()
-        elif "跳舞" in text or "dance" in text.lower():
-            await self._dance()
-    
-    async def _say_hello(self):
-        """Say hello with motion"""
-        if self.state.motion_controller:
-            # Nod
-            await self.state.motion_controller.nod(count=2, duration=0.3)
-            # Look up
-            import numpy as np
-            from scipy.spatial.transform import Rotation as R
-            pose = np.eye(4)
-            pose[:3, :3] = R.from_euler('xyz', [15, 0, 0], degrees=True).as_matrix()
-            await self.state.motion_controller.move_head(pose, duration=0.5)
-    
-    async def _dance(self):
-        """Perform a dance"""
-        if self.state.motion_controller:
-            # Simple dance: shake head
-            await self.state.motion_controller.shake(count=3, duration=0.4)

src/reachy_mini_ha_voice/audio/__init__.py

@@ -1,8 +0,0 @@
-"""
-Audio processing module for Reachy Mini Voice Assistant
-"""
-
-from .adapter import AudioAdapter, MicrophoneArray, Speaker
-from .processor import AudioProcessor
-
-__all__ = ["AudioAdapter", "MicrophoneArray", "Speaker", "AudioProcessor"]

src/reachy_mini_ha_voice/audio/adapter.py

@@ -1,260 +0,0 @@
-"""
-Audio device adapter for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Callable, List, Optional
-import sounddevice as sd
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class AudioDevice:
-    """Audio device information"""
-    index: int
-    name: str
-    sample_rate: int
-    channels: int
-    is_input: bool
-    is_output: bool
-
-
-class AudioAdapter(ABC):
-    """Abstract base class for audio device adapter"""
-    
-    @abstractmethod
-    async def list_input_devices(self) -> List[AudioDevice]:
-        """List available audio input devices"""
-        pass
-    
-    @abstractmethod
-    async def list_output_devices(self) -> List[AudioDevice]:
-        """List available audio output devices"""
-        pass
-    
-    @abstractmethod
-    async def start_recording(
-        self,
-        device_id: Optional[str],
-        callback: Callable[[bytes], None],
-        sample_rate: int = 16000,
-        channels: int = 1,
-        block_size: int = 1024
-    ):
-        """Start recording audio"""
-        pass
-    
-    @abstractmethod
-    async def stop_recording(self):
-        """Stop recording audio"""
-        pass
-    
-    @abstractmethod
-    async def play_audio(
-        self,
-        audio_data: bytes,
-        device_id: Optional[str],
-        sample_rate: int = 16000,
-        channels: int = 1
-    ):
-        """Play audio"""
-        pass
-
-
-class MicrophoneArray(AudioAdapter):
-    """Microphone array adapter for Reachy Mini"""
-    
-    def __init__(self, sample_rate: int = 16000, channels: int = 1):
-        self.sample_rate = sample_rate
-        self.channels = channels
-        self._stream = None
-        self._is_recording = False
-        self._callback = None
-        self._loop = None
-    
-    async def list_input_devices(self) -> List[AudioDevice]:
-        """List available audio input devices"""
-        devices = []
-        for i, device in enumerate(sd.query_devices()):
-            if device['max_input_channels'] > 0:
-                devices.append(AudioDevice(
-                    index=i,
-                    name=device['name'],
-                    sample_rate=int(device['default_samplerate']),
-                    channels=device['max_input_channels'],
-                    is_input=True,
-                    is_output=False
-                ))
-        return devices
-    
-    async def list_output_devices(self) -> List[AudioDevice]:
-        """List available audio output devices"""
-        devices = []
-        for i, device in enumerate(sd.query_devices()):
-            if device['max_output_channels'] > 0:
-                devices.append(AudioDevice(
-                    index=i,
-                    name=device['name'],
-                    sample_rate=int(device['default_samplerate']),
-                    channels=device['max_output_channels'],
-                    is_input=False,
-                    is_output=True
-                ))
-        return devices
-    
-    async def start_recording(
-        self,
-        device_id: Optional[str],
-        callback: Callable[[bytes], None],
-        sample_rate: int = 16000,
-        channels: int = 1,
-        block_size: int = 1024
-    ):
-        """Start recording from microphone"""
-        if self._is_recording:
-            logger.warning("Already recording")
-            return
-        
-        self._callback = callback
-        self._loop = asyncio.get_event_loop()
-        self._is_recording = True
-        
-        def audio_callback(indata, frames, time, status):
-            """Callback for audio stream"""
-            if status:
-                logger.warning(f"Audio callback status: {status}")
-            
-            if not self._is_recording:
-                return
-            
-            # Convert to 16-bit PCM
-            audio_data = (
-                (np.clip(indata, -1.0, 1.0) * 32767.0)
-                .astype("<i2")
-                .tobytes()
-            )
-            
-            # Call the callback in the event loop
-            if self._loop and self._callback:
-                self._loop.call_soon_threadsafe(self._callback, audio_data)
-        
-        try:
-            self._stream = sd.InputStream(
-                device=device_id,
-                samplerate=sample_rate,
-                channels=channels,
-                blocksize=block_size,
-                callback=audio_callback,
-                dtype='float32'
-            )
-            self._stream.start()
-            logger.info(f"Started recording from device: {device_id or 'default'}")
-        except Exception as e:
-            logger.error(f"Failed to start recording: {e}")
-            self._is_recording = False
-            raise
-    
-    async def stop_recording(self):
-        """Stop recording"""
-        if not self._is_recording:
-            return
-        
-        self._is_recording = False
-        
-        if self._stream:
-            try:
-                self._stream.stop()
-                self._stream.close()
-                logger.info("Stopped recording")
-            except Exception as e:
-                logger.error(f"Failed to stop recording: {e}")
-            finally:
-                self._stream = None
-        
-        self._callback = None
-        self._loop = None
-
-
-class Speaker(AudioAdapter):
-    """Speaker adapter for Reachy Mini"""
-    
-    def __init__(self, sample_rate: int = 16000):
-        self.sample_rate = sample_rate
-        self._stream = None
-        self._is_playing = False
-    
-    async def list_input_devices(self) -> List[AudioDevice]:
-        """List available audio input devices (not applicable for speaker)"""
-        return []
-    
-    async def list_output_devices(self) -> List[AudioDevice]:
-        """List available audio output devices"""
-        devices = []
-        for i, device in enumerate(sd.query_devices()):
-            if device['max_output_channels'] > 0:
-                devices.append(AudioDevice(
-                    index=i,
-                    name=device['name'],
-                    sample_rate=int(device['default_samplerate']),
-                    channels=device['max_output_channels'],
-                    is_input=False,
-                    is_output=True
-                ))
-        return devices
-    
-    async def start_recording(
-        self,
-        device_id: Optional[str],
-        callback: Callable[[bytes], None],
-        sample_rate: int = 16000,
-        channels: int = 1,
-        block_size: int = 1024
-    ):
-        """Start recording (not applicable for speaker)"""
-        raise NotImplementedError("Speaker does not support recording")
-    
-    async def stop_recording(self):
-        """Stop recording (not applicable for speaker)"""
-        raise NotImplementedError("Speaker does not support recording")
-    
-    async def play_audio(
-        self,
-        audio_data: bytes,
-        device_id: Optional[str],
-        sample_rate: int = 16000,
-        channels: int = 1
-    ):
-        """Play audio to speaker"""
-        try:
-            # Convert from 16-bit PCM to float32
-            audio_array = np.frombuffer(audio_data, dtype="<i2").astype(np.float32) / 32768.0
-            
-            # Play audio
-            sd.play(audio_array, samplerate=sample_rate, device=device_id)
-            sd.wait()
-            logger.debug("Audio playback completed")
-        except Exception as e:
-            logger.error(f"Failed to play audio: {e}")
-            raise
-
-
-async def list_audio_devices():
-    """List all available audio devices"""
-    microphone = MicrophoneArray()
-    
-    print("\n=== Audio Input Devices ===")
-    input_devices = await microphone.list_input_devices()
-    for device in input_devices:
-        print(f"{device.index}: {device.name} ({device.sample_rate}Hz, {device.channels}ch)")
-    
-    print("\n=== Audio Output Devices ===")
-    output_devices = await microphone.list_output_devices()
-    for device in output_devices:
-        print(f"{device.index}: {device.name} ({device.sample_rate}Hz, {device.channels}ch)")
-    
-    print()

src/reachy_mini_ha_voice/audio/processor.py

@@ -1,94 +0,0 @@
-"""
-Audio processor for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from queue import Queue
-from typing import Optional, Callable
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-
-class AudioProcessor:
-    """Process audio chunks for wake word detection and streaming"""
-    
-    def __init__(
-        self,
-        sample_rate: int = 16000,
-        channels: int = 1,
-        block_size: int = 1024
-    ):
-        self.sample_rate = sample_rate
-        self.channels = channels
-        self.block_size = block_size
-        
-        self._audio_queue: Queue[bytes] = Queue()
-        self._is_processing = False
-        self._wake_word_callbacks: list[Callable[[bytes], None]] = []
-        self._stream_callbacks: list[Callable[[bytes], None]] = []
-    
-    def add_wake_word_callback(self, callback: Callable[[bytes], None]):
-        """Add a callback for wake word detection"""
-        self._wake_word_callbacks.append(callback)
-    
-    def add_stream_callback(self, callback: Callable[[bytes], None]):
-        """Add a callback for audio streaming"""
-        self._stream_callbacks.append(callback)
-    
-    async def process_audio_chunk(self, audio_chunk: bytes):
-        """Process an audio chunk"""
-        # Convert to numpy array for processing
-        audio_array = np.frombuffer(audio_chunk, dtype=np.int16).astype(np.float32) / 32768.0
-        
-        # Call wake word callbacks
-        for callback in self._wake_word_callbacks:
-            try:
-                callback(audio_chunk)
-            except Exception as e:
-                logger.error(f"Error in wake word callback: {e}")
-        
-        # Call stream callbacks
-        for callback in self._stream_callbacks:
-            try:
-                callback(audio_chunk)
-            except Exception as e:
-                logger.error(f"Error in stream callback: {e}")
-    
-    async def start_processing(self):
-        """Start processing audio"""
-        if self._is_processing:
-            logger.warning("Already processing audio")
-            return
-        
-        self._is_processing = True
-        logger.info("Started audio processing")
-    
-    async def stop_processing(self):
-        """Stop processing audio"""
-        if not self._is_processing:
-            return
-        
-        self._is_processing = False
-        logger.info("Stopped audio processing")
-    
-    def is_processing(self) -> bool:
-        """Check if processing audio"""
-        return self._is_processing
-    
-    async def process_audio_stream(self, audio_stream: Callable[[], bytes]):
-        """Process a continuous audio stream"""
-        await self.start_processing()
-        
-        try:
-            while self._is_processing:
-                audio_chunk = audio_stream()
-                if audio_chunk:
-                    await self.process_audio_chunk(audio_chunk)
-                else:
-                    await asyncio.sleep(0.001)
-        except Exception as e:
-            logger.error(f"Error processing audio stream: {e}")
-        finally:
-            await self.stop_processing()

src/reachy_mini_ha_voice/config/__init__.py

@@ -1,7 +0,0 @@
-"""
-Configuration management module for Reachy Mini Voice Assistant
-"""
-
-from .manager import ConfigManager
-
-__all__ = ["ConfigManager"]

src/reachy_mini_ha_voice/config/manager.py

@@ -1,159 +0,0 @@
-"""
-Configuration manager for Reachy Mini Voice Assistant
-"""
-
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class ConfigManager:
-    """Manage application configuration"""
-    
-    def __init__(self, config_path: str = "config.json"):
-        self.config_path = Path(config_path)
-        self.config = self.load_config()
-    
-    def load_config(self) -> dict:
-        """Load configuration from file"""
-        if self.config_path.exists():
-            try:
-                with open(self.config_path, 'r', encoding='utf-8') as f:
-                    config = json.load(f)
-                logger.info(f"Loaded configuration from {self.config_path}")
-                return config
-            except Exception as e:
-                logger.error(f"Failed to load configuration: {e}")
-                logger.info("Using default configuration")
-                return self.get_default_config()
-        else:
-            logger.info("Configuration file not found, using defaults")
-            return self.get_default_config()
-    
-    def save_config(self):
-        """Save configuration to file"""
-        try:
-            with open(self.config_path, 'w', encoding='utf-8') as f:
-                json.dump(self.config, f, indent=2, ensure_ascii=False)
-            logger.info(f"Saved configuration to {self.config_path}")
-        except Exception as e:
-            logger.error(f"Failed to save configuration: {e}")
-            raise
-    
-    def get_default_config(self) -> dict:
-        """Get default configuration"""
-        return {
-            "audio": {
-                "input_device": None,
-                "output_device": None,
-                "sample_rate": 16000,
-                "channels": 1,
-                "block_size": 1024
-            },
-            "voice": {
-                "wake_word": "okay_nabu",
-                "wake_word_dirs": ["wakewords"]
-            },
-            "motion": {
-                "enabled": True,
-                "speech_reactive": True,
-                "face_tracking": False
-            },
-            "esphome": {
-                "host": "0.0.0.0",
-                "port": 6053,
-                "name": "Reachy Mini"
-            },
-            "robot": {
-                "host": "localhost",
-                "wireless": False
-            },
-            "logging": {
-                "level": "INFO",
-                "file": "reachy_mini_ha_voice.log"
-            }
-        }
-    
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get configuration value by key (supports nested keys with dots)"""
-        keys = key.split('.')
-        value = self.config
-        for k in keys:
-            if isinstance(value, dict):
-                value = value.get(k, default)
-            else:
-                return default
-        return value
-    
-    def set(self, key: str, value: Any):
-        """Set configuration value by key (supports nested keys with dots)"""
-        keys = key.split('.')
-        config = self.config
-        for k in keys[:-1]:
-            config = config.setdefault(k, {})
-        config[keys[-1]] = value
-        self.save_config()
-    
-    def get_audio_config(self) -> dict:
-        """Get audio configuration"""
-        return self.get("audio", {})
-    
-    def get_voice_config(self) -> dict:
-        """Get voice configuration"""
-        return self.get("voice", {})
-    
-    def get_motion_config(self) -> dict:
-        """Get motion configuration"""
-        return self.get("motion", {})
-    
-    def get_esphome_config(self) -> dict:
-        """Get ESPHome configuration"""
-        return self.get("esphome", {})
-    
-    def get_robot_config(self) -> dict:
-        """Get robot configuration"""
-        return self.get("robot", {})
-    
-    def get_gradio_config(self) -> dict:
-        """Get Gradio configuration"""
-        return self.get("gradio", {})
-    
-    def update_audio_config(self, **kwargs):
-        """Update audio configuration"""
-        audio_config = self.config.setdefault("audio", {})
-        audio_config.update(kwargs)
-        self.save_config()
-    
-    def update_voice_config(self, **kwargs):
-        """Update voice configuration"""
-        voice_config = self.config.setdefault("voice", {})
-        voice_config.update(kwargs)
-        self.save_config()
-    
-    def update_motion_config(self, **kwargs):
-        """Update motion configuration"""
-        motion_config = self.config.setdefault("motion", {})
-        motion_config.update(kwargs)
-        self.save_config()
-    
-    def update_esphome_config(self, **kwargs):
-        """Update ESPHome configuration"""
-        esphome_config = self.config.setdefault("esphome", {})
-        esphome_config.update(kwargs)
-        self.save_config()
-    
-    def update_robot_config(self, **kwargs):
-        """Update robot configuration"""
-        robot_config = self.config.setdefault("robot", {})
-        robot_config.update(kwargs)
-        self.save_config()
-    
-    def update_gradio_config(self, **kwargs):
-        """Update Gradio configuration"""
-        gradio_config = self.config.setdefault("gradio", {})
-        gradio_config.update(kwargs)
-        self.save_config()

src/reachy_mini_ha_voice/esphome/__init__.py

@@ -1,8 +0,0 @@
-"""
-ESPHome protocol module for Reachy Mini Voice Assistant
-"""
-
-from .server import ESPHomeServer, VoiceSatelliteProtocol
-from .protocol import VoiceAssistantEventType
-
-__all__ = ["ESPHomeServer", "VoiceSatelliteProtocol", "VoiceAssistantEventType"]

src/reachy_mini_ha_voice/esphome/protocol.py

@@ -1,34 +0,0 @@
-"""
-ESPHome protocol for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from enum import Enum
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-class VoiceAssistantEventType(Enum):
-    """Voice assistant event types"""
-    VOICE_ASSISTANT_START = 0
-    VOICE_ASSISTANT_END = 1
-    VOICE_ASSISTANT_ERROR = 2
-    VOICE_ASSISTANT_STT_START = 3
-    VOICE_ASSISTANT_STT_END = 4
-    VOICE_ASSISTANT_TTS_START = 5
-    VOICE_ASSISTANT_TTS_END = 6
-    VOICE_ASSISTANT_INTENT_START = 7
-    VOICE_ASSISTANT_INTENT_END = 8
-    VOICE_ASSISTANT_WAKE_WORD_START = 9
-    VOICE_ASSISTANT_WAKE_WORD_END = 10
-
-
-class VoiceAssistantFeature(Enum):
-    """Voice assistant features"""
-    VOICE_ASSISTANT = 1
-    API_AUDIO = 2
-    ANNOUNCE = 4
-    START_CONVERSATION = 8
-    TIMERS = 16

src/reachy_mini_ha_voice/esphome/server.py

@@ -1,164 +0,0 @@
-"""
-ESPHome server for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from typing import Optional, Callable, List
-from .protocol import VoiceAssistantEventType, VoiceAssistantFeature
-
-logger = logging.getLogger(__name__)
-
-
-class ESPHomeServer:
-    """ESPHome protocol server"""
-    
-    def __init__(self, host: str = "0.0.0.0", port: int = 6053):
-        self.host = host
-        self.port = port
-        self._server: Optional[asyncio.Server] = None
-        self._is_running = False
-        self._clients: List = []
-        self._audio_callback: Optional[Callable[[bytes], None]] = None
-        self._event_callback: Optional[Callable[[VoiceAssistantEventType, dict], None]] = None
-    
-    async def start(self):
-        """Start ESPHome server"""
-        if self._is_running:
-            logger.warning("ESPHome server already running")
-            return
-        
-        try:
-            self._server = await asyncio.start_server(
-                self._handle_client,
-                self.host,
-                self.port
-            )
-            self._is_running = True
-            
-            logger.info(f"ESPHome server started on {self.host}:{self.port}")
-        except Exception as e:
-            logger.error(f"Failed to start ESPHome server: {e}")
-            raise
-    
-    async def stop(self):
-        """Stop ESPHome server"""
-        if not self._is_running:
-            return
-        
-        self._is_running = False
-        
-        # Close all clients
-        for client in self._clients:
-            client.close()
-        self._clients.clear()
-        
-        # Close server
-        if self._server:
-            self._server.close()
-            await self._server.wait_closed()
-        
-        logger.info("ESPHome server stopped")
-    
-    def set_audio_callback(self, callback: Callable[[bytes], None]):
-        """Set audio callback"""
-        self._audio_callback = callback
-    
-    def set_event_callback(self, callback: Callable[[VoiceAssistantEventType, dict], None]):
-        """Set event callback"""
-        self._event_callback = callback
-    
-    async def send_audio(self, audio_data: bytes):
-        """Send audio data to all clients"""
-        for client in self._clients:
-            try:
-                client.write(audio_data)
-                await client.drain()
-            except Exception as e:
-                logger.error(f"Error sending audio to client: {e}")
-    
-    async def send_event(self, event_type: VoiceAssistantEventType, data: dict):
-        """Send event to all clients"""
-        if self._event_callback:
-            try:
-                self._event_callback(event_type, data)
-            except Exception as e:
-                logger.error(f"Error in event callback: {e}")
-    
-    async def _handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
-        """Handle client connection"""
-        client_addr = writer.get_extra_info('peername')
-        logger.info(f"Client connected: {client_addr}")
-        
-        self._clients.append(writer)
-        
-        try:
-            while self._is_running:
-                # Read data from client
-                data = await reader.read(4096)
-                if not data:
-                    break
-                
-                # Process data (simplified ESPHome protocol)
-                await self._process_data(data)
-        except Exception as e:
-            logger.error(f"Error handling client {client_addr}: {e}")
-        finally:
-            self._clients.remove(writer)
-            writer.close()
-            await writer.wait_closed()
-            logger.info(f"Client disconnected: {client_addr}")
-    
-    async def _process_data(self, data: bytes):
-        """Process incoming data"""
-        # Simplified ESPHome protocol processing
-        # In a real implementation, this would parse ESPHome frames
-        logger.debug(f"Received {len(data)} bytes from client")
-
-
-class VoiceSatelliteProtocol:
-    """Voice satellite protocol handler"""
-    
-    def __init__(self, state):
-        self.state = state
-        self._is_streaming = False
-        self._refractory_period = 2.0  # seconds
-        self._last_wake_word_time = 0.0
-    
-    async def handle_message(self, msg):
-        """Handle ESPHome message"""
-        # Simplified message handling
-        logger.debug(f"Received message: {msg}")
-    
-    async def handle_audio(self, audio_chunk: bytes):
-        """Handle audio chunk"""
-        if self._is_streaming and self.state.esphome_server:
-            await self.state.esphome_server.send_audio(audio_chunk)
-    
-    async def handle_wake_word(self):
-        """Handle wake word detection"""
-        current_time = asyncio.get_event_loop().time()
-        
-        # Check refractory period
-        if current_time - self._last_wake_word_time < self._refractory_period:
-            logger.debug("Wake word in refractory period, ignoring")
-            return
-        
-        self._last_wake_word_time = current_time
-        
-        # Send wake word event
-        if self.state.esphome_server:
-            await self.state.esphome_server.send_event(
-                VoiceAssistantEventType.VOICE_ASSISTANT_WAKE_WORD_END,
-                {"wake_word": "detected"}
-            )
-        
-        # Start streaming
-        self._is_streaming = True
-        
-        logger.info("Wake word detected, started streaming")
-    
-    async def stop_streaming(self):
-        """Stop audio streaming"""
-        self._is_streaming = False
-        logger.info("Stopped streaming")

src/reachy_mini_ha_voice/main.py

@@ -1,197 +0,0 @@
-"""
-Main entry point for Reachy Mini Home Assistant Voice Assistant
-"""
-
-import argparse
-import asyncio
-import logging
-import signal
-import sys
-from pathlib import Path
-
-from .config.manager import ConfigManager
-from .audio.adapter import AudioAdapter
-from .voice.detector import WakeWordDetector
-from .motion.controller import MotionController
-from .esphome.server import ESPHomeServer
-from .app import ReachyMiniVoiceApp
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-
-def parse_args():
-    """Parse command line arguments"""
-    parser = argparse.ArgumentParser(
-        description="Reachy Mini Home Assistant Voice Assistant"
-    )
-    
-    parser.add_argument(
-        "--name",
-        type=str,
-        default="Reachy Mini",
-        help="Name of the voice assistant (default: Reachy Mini)"
-    )
-    
-    parser.add_argument(
-        "--config",
-        type=str,
-        default="config.json",
-        help="Path to configuration file (default: config.json)"
-    )
-    
-    parser.add_argument(
-        "--audio-input-device",
-        type=str,
-        default=None,
-        help="Audio input device name (default: auto-detect)"
-    )
-    
-    parser.add_argument(
-        "--audio-output-device",
-        type=str,
-        default=None,
-        help="Audio output device name (default: auto-detect)"
-    )
-    
-    parser.add_argument(
-        "--list-input-devices",
-        action="store_true",
-        help="List available audio input devices and exit"
-    )
-    
-    parser.add_argument(
-        "--list-output-devices",
-        action="store_true",
-        help="List available audio output devices and exit"
-    )
-    
-    parser.add_argument(
-        "--wake-model",
-        type=str,
-        default="okay_nabu",
-        help="Wake word model name (default: okay_nabu)"
-    )
-    
-    parser.add_argument(
-        "--wake-word-dir",
-        type=str,
-        action="append",
-        help="Additional wake word directory (can be used multiple times)"
-    )
-    
-    parser.add_argument(
-        "--host",
-        type=str,
-        default="0.0.0.0",
-        help="ESPHome server host (default: 0.0.0.0)"
-    )
-    
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=6053,
-        help="ESPHome server port (default: 6053)"
-    )
-    
-    parser.add_argument(
-        "--robot-host",
-        type=str,
-        default="localhost",
-        help="Reachy Mini robot host (default: localhost)"
-    )
-    
-    parser.add_argument(
-        "--wireless",
-        action="store_true",
-        help="Use wireless version of Reachy Mini"
-    )
-    
-    parser.add_argument(
-        "--gradio",
-        action="store_true",
-        help="Launch Gradio web UI"
-    )
-    
-    parser.add_argument(
-        "--debug",
-        action="store_true",
-        help="Enable debug logging"
-    )
-    
-    return parser.parse_args()
-
-
-async def list_audio_devices():
-    """List available audio devices"""
-    import sounddevice as sd
-    
-    print("\n=== Audio Input Devices ===")
-    devices = sd.query_devices()
-    for i, device in enumerate(devices):
-        if device['max_input_channels'] > 0:
-            print(f"{i}: {device['name']}")
-    
-    print("\n=== Audio Output Devices ===")
-    for i, device in enumerate(devices):
-        if device['max_output_channels'] > 0:
-            print(f"{i}: {device['name']}")
-    
-    print()
-
-
-async def main():
-    """Main entry point"""
-    args = parse_args()
-    
-    # Set debug logging if requested
-    if args.debug:
-        logging.getLogger().setLevel(logging.DEBUG)
-        logger.debug("Debug logging enabled")
-    
-    # List audio devices if requested
-    if args.list_input_devices or args.list_output_devices:
-        await list_audio_devices()
-        return
-    
-    # Load configuration
-    config = ConfigManager(args.config)
-    logger.info(f"Loaded configuration from {args.config}")
-    
-    # Create application
-    app = ReachyMiniVoiceApp(
-        name=args.name,
-        config=config,
-        audio_input_device=args.audio_input_device,
-        audio_output_device=args.audio_output_device,
-        wake_model=args.wake_model,
-        wake_word_dirs=args.wake_word_dir,
-        host=args.host,
-        port=args.port,
-        robot_host=args.robot_host,
-        wireless=args.wireless,
-        gradio=args.gradio
-    )
-    
-    # Setup signal handlers
-    def signal_handler(sig, frame):
-        logger.info(f"Received signal {sig}, shutting down...")
-        asyncio.create_task(app.stop())
-    
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-    
-    # Start application
-    try:
-        await app.start()
-    except Exception as e:
-        logger.error(f"Error starting application: {e}", exc_info=True)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

src/reachy_mini_ha_voice/motion/__init__.py

@@ -1,8 +0,0 @@
-"""
-Motion control module for Reachy Mini Voice Assistant
-"""
-
-from .controller import MotionController, ReachyMiniMotionController
-from .queue import MotionQueue, Motion
-
-__all__ = ["MotionController", "ReachyMiniMotionController", "MotionQueue", "Motion"]

src/reachy_mini_ha_voice/motion/controller.py

@@ -1,261 +0,0 @@
-"""
-Motion controller for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from typing import Optional
-import numpy as np
-from scipy.spatial.transform import Rotation as R
-
-logger = logging.getLogger(__name__)
-
-
-class MotionController(ABC):
-    """Abstract base class for motion controller"""
-    
-    @abstractmethod
-    async def connect(self, host: str = 'localhost'):
-        """Connect to robot"""
-        pass
-    
-    @abstractmethod
-    async def disconnect(self):
-        """Disconnect from robot"""
-        pass
-    
-    @abstractmethod
-    async def wake_up(self):
-        """Wake up robot"""
-        pass
-    
-    @abstractmethod
-    async def turn_off(self):
-        """Turn off robot"""
-        pass
-    
-    @abstractmethod
-    async def move_head(self, pose: np.ndarray, duration: float = 1.0):
-        """Move head to pose"""
-        pass
-    
-    @abstractmethod
-    async def move_antennas(self, left: float, right: float, duration: float = 1.0):
-        """Move antennas"""
-        pass
-    
-    @abstractmethod
-    async def is_connected(self) -> bool:
-        """Check if connected"""
-        pass
-
-
-class ReachyMiniMotionController(MotionController):
-    """Reachy Mini motion controller"""
-    
-    def __init__(self):
-        self.reachy_mini = None
-        self._connected = False
-        self._speech_reactive = False
-        self._speech_task = None
-    
-    async def connect(self, host: str = 'localhost'):
-        """Connect to Reachy Mini"""
-        try:
-            from reachy_mini import ReachyMini
-            
-            self.reachy_mini = ReachyMini(host=host)
-            self._connected = True
-            
-            logger.info(f"Connected to Reachy Mini at {host}")
-        except ImportError:
-            logger.error("reachy-mini not installed. Install with: pip install reachy-mini")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to connect to Reachy Mini: {e}")
-            raise
-    
-    async def disconnect(self):
-        """Disconnect from Reachy Mini"""
-        if self.reachy_mini:
-            try:
-                await self.turn_off()
-            except Exception as e:
-                logger.error(f"Error turning off robot: {e}")
-            finally:
-                self.reachy_mini = None
-                self._connected = False
-                logger.info("Disconnected from Reachy Mini")
-    
-    async def wake_up(self):
-        """Wake up robot"""
-        if not self._connected or self.reachy_mini is None:
-            logger.warning("Not connected to robot")
-            return
-        
-        try:
-            self.reachy_mini.wake_up()
-            logger.info("Robot woke up")
-        except Exception as e:
-            logger.error(f"Failed to wake up robot: {e}")
-            raise
-    
-    async def turn_off(self):
-        """Turn off robot"""
-        if not self._connected or self.reachy_mini is None:
-            logger.warning("Not connected to robot")
-            return
-        
-        try:
-            self.reachy_mini.turn_off()
-            logger.info("Robot turned off")
-        except Exception as e:
-            logger.error(f"Failed to turn off robot: {e}")
-            raise
-    
-    async def move_head(self, pose: np.ndarray, duration: float = 1.0):
-        """Move head to pose"""
-        if not self._connected or self.reachy_mini is None:
-            logger.warning("Not connected to robot")
-            return
-        
-        try:
-            self.reachy_mini.goto_target(head=pose, duration=duration)
-            logger.debug(f"Moved head (duration: {duration}s)")
-        except Exception as e:
-            logger.error(f"Failed to move head: {e}")
-            raise
-    
-    async def move_antennas(self, left: float, right: float, duration: float = 1.0):
-        """Move antennas"""
-        if not self._connected or self.reachy_mini is None:
-            logger.warning("Not connected to robot")
-            return
-        
-        try:
-            self.reachy_mini.goto_target(antennas=[left, right], duration=duration)
-            logger.debug(f"Moved antennas (left: {left}, right: {right})")
-        except Exception as e:
-            logger.error(f"Failed to move antennas: {e}")
-            raise
-    
-    async def nod(self, count: int = 1, duration: float = 0.5):
-        """Nod head"""
-        for _ in range(count):
-            # Nod down
-            pose_down = np.eye(4)
-            pose_down[:3, :3] = R.from_euler('xyz', [15, 0, 0], degrees=True).as_matrix()
-            await self.move_head(pose_down, duration=duration / 2)
-            
-            # Nod up
-            pose_up = np.eye(4)
-            pose_up[:3, :3] = R.from_euler('xyz', [-15, 0, 0], degrees=True).as_matrix()
-            await self.move_head(pose_up, duration=duration / 2)
-    
-    async def shake(self, count: int = 1, duration: float = 0.5):
-        """Shake head"""
-        for _ in range(count):
-            # Shake left
-            pose_left = np.eye(4)
-            pose_left[:3, :3] = R.from_euler('xyz', [0, 0, -20], degrees=True).as_matrix()
-            await self.move_head(pose_left, duration=duration / 2)
-            
-            # Shake right
-            pose_right = np.eye(4)
-            pose_right[:3, :3] = R.from_euler('xyz', [0, 0, 20], degrees=True).as_matrix()
-            await self.move_head(pose_right, duration=duration / 2)
-    
-    async def look_at(self, x: float = 0.5, y: float = 0.0, z: float = 0.0, duration: float = 1.0):
-        """Look at a point"""
-        # Calculate yaw and pitch
-        yaw = np.arctan2(x, z)
-        pitch = np.arctan2(y, np.sqrt(x**2 + z**2))
-        
-        # Create pose
-        pose = np.eye(4)
-        pose[:3, :3] = R.from_euler('xyz', [pitch, 0, yaw], degrees=True).as_matrix()
-        
-        await self.move_head(pose, duration=duration)
-    
-    async def start_speech_reactive_motion(self):
-        """Start speech reactive motion"""
-        if self._speech_reactive:
-            return
-        
-        self._speech_reactive = True
-        self._speech_task = asyncio.create_task(self._speech_reactive_loop())
-        logger.info("Started speech reactive motion")
-    
-    async def stop_speech_reactive_motion(self):
-        """Stop speech reactive motion"""
-        if not self._speech_reactive:
-            return
-        
-        self._speech_reactive = False
-        if self._speech_task:
-            self._speech_task.cancel()
-            try:
-                await self._speech_task
-            except asyncio.CancelledError:
-                pass
-        logger.info("Stopped speech reactive motion")
-    
-    async def _speech_reactive_loop(self):
-        """Speech reactive motion loop"""
-        try:
-            while self._speech_reactive:
-                # Generate subtle wobble
-                roll = np.sin(asyncio.get_event_loop().time() * 2) * 3
-                pose = np.eye(4)
-                pose[:3, :3] = R.from_euler('xyz', [0, 0, roll], degrees=True).as_matrix()
-                
-                await self.move_head(pose, duration=0.1)
-                await asyncio.sleep(0.1)
-        except asyncio.CancelledError:
-            logger.debug("Speech reactive loop cancelled")
-        except Exception as e:
-            logger.error(f"Error in speech reactive loop: {e}")
-    
-    async def is_connected(self) -> bool:
-        """Check if connected"""
-        return self._connected
-
-
-class MockMotionController(MotionController):
-    """Mock motion controller for testing"""
-    
-    def __init__(self):
-        self._connected = False
-    
-    async def connect(self, host: str = 'localhost'):
-        """Connect to mock robot"""
-        self._connected = True
-        logger.info("Connected to mock robot")
-    
-    async def disconnect(self):
-        """Disconnect from mock robot"""
-        self._connected = False
-        logger.info("Disconnected from mock robot")
-    
-    async def wake_up(self):
-        """Wake up mock robot"""
-        logger.info("Mock robot woke up")
-    
-    async def turn_off(self):
-        """Turn off mock robot"""
-        logger.info("Mock robot turned off")
-    
-    async def move_head(self, pose: np.ndarray, duration: float = 1.0):
-        """Move mock head"""
-        logger.debug(f"Mock head moved (duration: {duration}s)")
-        await asyncio.sleep(duration)
-    
-    async def move_antennas(self, left: float, right: float, duration: float = 1.0):
-        """Move mock antennas"""
-        logger.debug(f"Mock antennas moved (left: {left}, right: {right})")
-        await asyncio.sleep(duration)
-    
-    async def is_connected(self) -> bool:
-        """Check if connected"""
-        return self._connected

src/reachy_mini_ha_voice/motion/queue.py

@@ -1,162 +0,0 @@
-"""
-Motion queue for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from dataclasses import dataclass
-from enum import Enum
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-class MotionPriority(Enum):
-    """Motion priority levels"""
-    HIGH = 1
-    MEDIUM = 2
-    LOW = 3
-
-
-@dataclass
-class Motion:
-    """Motion command"""
-    name: str
-    execute: callable
-    priority: MotionPriority = MotionPriority.MEDIUM
-    duration: float = 1.0
-
-
-class MotionQueue:
-    """Motion queue manager"""
-    
-    def __init__(self):
-        self.high_priority = asyncio.Queue()
-        self.medium_priority = asyncio.Queue()
-        self.low_priority = asyncio.Queue()
-        self.is_running = False
-        self._current_motion: Optional[Motion] = None
-        self._task: Optional[asyncio.Task] = None
-    
-    async def add_motion(self, motion: Motion):
-        """Add motion to queue based on priority"""
-        if motion.priority == MotionPriority.HIGH:
-            await self.high_priority.put(motion)
-        elif motion.priority == MotionPriority.MEDIUM:
-            await self.medium_priority.put(motion)
-        elif motion.priority == MotionPriority.LOW:
-            await self.low_priority.put(motion)
-        else:
-            logger.warning(f"Unknown priority: {motion.priority}")
-            return
-        
-        logger.debug(f"Added motion '{motion.name}' to queue (priority: {motion.priority.name})")
-    
-    async def add_high_priority(self, name: str, execute: callable, duration: float = 1.0):
-        """Add high priority motion"""
-        motion = Motion(name, execute, MotionPriority.HIGH, duration)
-        await self.add_motion(motion)
-    
-    async def add_medium_priority(self, name: str, execute: callable, duration: float = 1.0):
-        """Add medium priority motion"""
-        motion = Motion(name, execute, MotionPriority.MEDIUM, duration)
-        await self.add_motion(motion)
-    
-    async def add_low_priority(self, name: str, execute: callable, duration: float = 1.0):
-        """Add low priority motion"""
-        motion = Motion(name, execute, MotionPriority.LOW, duration)
-        await self.add_motion(motion)
-    
-    async def start(self):
-        """Start processing motion queue"""
-        if self.is_running:
-            logger.warning("Motion queue already running")
-            return
-        
-        self.is_running = True
-        self._task = asyncio.create_task(self._process_queue())
-        logger.info("Started motion queue")
-    
-    async def stop(self):
-        """Stop processing motion queue"""
-        if not self.is_running:
-            return
-        
-        self.is_running = False
-        
-        if self._task:
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
-        
-        logger.info("Stopped motion queue")
-    
-    async def clear(self):
-        """Clear all queues"""
-        while not self.high_priority.empty():
-            await self.high_priority.get()
-        while not self.medium_priority.empty():
-            await self.medium_priority.get()
-        while not self.low_priority.empty():
-            await self.low_priority.get()
-        logger.info("Cleared motion queues")
-    
-    async def _process_queue(self):
-        """Process motion queue"""
-        try:
-            while self.is_running:
-                # Get next motion based on priority
-                motion = await self._get_next_motion()
-                
-                if motion is None:
-                    await asyncio.sleep(0.01)
-                    continue
-                
-                # Execute motion
-                self._current_motion = motion
-                logger.info(f"Executing motion: {motion.name}")
-                
-                try:
-                    await motion.execute()
-                except Exception as e:
-                    logger.error(f"Error executing motion '{motion.name}': {e}")
-                finally:
-                    self._current_motion = None
-        except asyncio.CancelledError:
-            logger.debug("Motion queue processing cancelled")
-        except Exception as e:
-            logger.error(f"Error in motion queue processing: {e}")
-    
-    async def _get_next_motion(self) -> Optional[Motion]:
-        """Get next motion based on priority"""
-        # Priority: HIGH > MEDIUM > LOW
-        if not self.high_priority.empty():
-            return await self.high_priority.get()
-        elif not self.medium_priority.empty():
-            return await self.medium_priority.get()
-        elif not self.low_priority.empty():
-            return await self.low_priority.get()
-        else:
-            return None
-    
-    def is_empty(self) -> bool:
-        """Check if all queues are empty"""
-        return (
-            self.high_priority.empty() and
-            self.medium_priority.empty() and
-            self.low_priority.empty()
-        )
-    
-    def get_queue_size(self) -> dict:
-        """Get size of each queue"""
-        return {
-            "high": self.high_priority.qsize(),
-            "medium": self.medium_priority.qsize(),
-            "low": self.low_priority.qsize()
-        }
-    
-    def get_current_motion(self) -> Optional[Motion]:
-        """Get currently executing motion"""
-        return self._current_motion

src/reachy_mini_ha_voice/state.py

@@ -1,83 +0,0 @@
-"""
-State management for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from dataclasses import dataclass, field
-from typing import Optional, Dict, Any
-from queue import Queue
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ServerState:
-    """Global server state"""
-    name: str
-    
-    # Configuration
-    config: Optional[Any] = None
-    
-    # Audio
-    microphone: Optional[Any] = None
-    speaker: Optional[Any] = None
-    audio_queue: Queue = field(default_factory=Queue)
-    
-    # Voice
-    wake_word_detector: Optional[Any] = None
-    stop_word_detector: Optional[Any] = None
-    active_wake_words: list = field(default_factory=list)
-    
-    # Motion
-    motion_controller: Optional[Any] = None
-    motion_queue: Optional[Any] = None
-    
-    # ESPHome
-    esphome_server: Optional[Any] = None
-    voice_satellite: Optional[Any] = None
-    
-    # Status
-    is_running: bool = False
-    is_streaming: bool = False
-    
-    # Callbacks
-    on_wake_word: Optional[callable] = None
-    on_stt_result: Optional[callable] = None
-    on_tts_audio: Optional[callable] = None
-    
-    def __post_init__(self):
-        """Post-initialization"""
-        logger.debug(f"ServerState initialized for {self.name}")
-    
-    async def cleanup(self):
-        """Cleanup resources"""
-        logger.info("Cleaning up ServerState")
-        
-        if self.microphone:
-            try:
-                await self.microphone.stop_recording()
-            except Exception as e:
-                logger.error(f"Error stopping microphone: {e}")
-        
-        if self.motion_controller:
-            try:
-                await self.motion_controller.stop_speech_reactive_motion()
-                await self.motion_controller.turn_off()
-                await self.motion_controller.disconnect()
-            except Exception as e:
-                logger.error(f"Error disconnecting motion controller: {e}")
-        
-        if self.motion_queue:
-            try:
-                await self.motion_queue.stop()
-            except Exception as e:
-                logger.error(f"Error stopping motion queue: {e}")
-        
-        if self.esphome_server:
-            try:
-                await self.esphome_server.stop()
-            except Exception as e:
-                logger.error(f"Error stopping ESPHome server: {e}")
-        
-        logger.info("ServerState cleanup complete")

src/reachy_mini_ha_voice/voice/__init__.py

@@ -1,14 +0,0 @@
-"""
-Voice processing module for Reachy Mini Voice Assistant
-
-Note: STT and TTS are handled by Home Assistant via ESPHome protocol.
-This module only contains offline wake word detection.
-"""
-
-from .detector import WakeWordDetector, MicroWakeWordDetector, OpenWakeWordDetector
-
-__all__ = [
-    "WakeWordDetector",
-    "MicroWakeWordDetector",
-    "OpenWakeWordDetector",
-]

src/reachy_mini_ha_voice/voice/detector.py

@@ -1,178 +0,0 @@
-"""
-Wake word detector for Reachy Mini Voice Assistant
-"""
-
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-class WakeWordDetector(ABC):
-    """Abstract base class for wake word detector"""
-    
-    @abstractmethod
-    async def load_model(self, model_path: str):
-        """Load wake word model"""
-        pass
-    
-    @abstractmethod
-    async def process_audio(self, audio_chunk: bytes) -> bool:
-        """Process audio chunk, return True if wake word detected"""
-        pass
-    
-    @abstractmethod
-    async def get_confidence(self) -> float:
-        """Get detection confidence"""
-        pass
-
-
-class MicroWakeWordDetector(WakeWordDetector):
-    """microWakeWord detector"""
-    
-    def __init__(self, model_path: str):
-        self.model = None
-        self.features = None
-        self.model_path = Path(model_path)
-        self._confidence = 0.0
-        self._loaded = False
-    
-    async def load_model(self, model_path: str):
-        """Load microWakeWord model"""
-        try:
-            from pymicro_wakeword import MicroWakeWord, MicroWakeWordFeatures
-            
-            self.model_path = Path(model_path)
-            
-            # Load features
-            self.features = MicroWakeWordFeatures()
-            
-            # Load model
-            self.model = MicroWakeWord.from_config(str(self.model_path))
-            self._loaded = True
-            
-            logger.info(f"Loaded microWakeWord model from {model_path}")
-        except ImportError:
-            logger.error("pymicro_wakeword not installed. Install with: pip install pymicro-wakeword")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to load microWakeWord model: {e}")
-            raise
-    
-    async def process_audio(self, audio_chunk: bytes) -> bool:
-        """Process audio chunk"""
-        if not self._loaded or self.model is None:
-            logger.warning("Model not loaded")
-            return False
-        
-        try:
-            import numpy as np
-            
-            # Convert audio to numpy array
-            audio_array = np.frombuffer(audio_chunk, dtype=np.int16).astype(np.float32) / 32768.0
-            
-            # Extract features
-            features = self.features.process_streaming(audio_array)
-            
-            # Process with model
-            for feature in features:
-                score = self.model.process_streaming(feature)
-                if score is not None:
-                    self._confidence = score
-                    if score >= 0.5:  # Threshold
-                        logger.info(f"Wake word detected with confidence: {score:.2f}")
-                        return True
-            
-            return False
-        except Exception as e:
-            logger.error(f"Error processing audio: {e}")
-            return False
-    
-    async def get_confidence(self) -> float:
-        """Get detection confidence"""
-        return self._confidence
-
-
-class OpenWakeWordDetector(WakeWordDetector):
-    """openWakeWord detector"""
-    
-    def __init__(self, model_path: str):
-        self.model = None
-        self.features = None
-        self.model_path = Path(model_path)
-        self._confidence = 0.0
-        self._loaded = False
-    
-    async def load_model(self, model_path: str):
-        """Load openWakeWord model"""
-        try:
-            from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
-            
-            self.model_path = Path(model_path)
-            
-            # Load features
-            self.features = OpenWakeWordFeatures.from_builtin()
-            
-            # Load model
-            self.model = OpenWakeWord(str(self.model_path))
-            self._loaded = True
-            
-            logger.info(f"Loaded openWakeWord model from {model_path}")
-        except ImportError:
-            logger.error("pyopen_wakeword not installed. Install with: pip install pyopen-wakeword")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to load openWakeWord model: {e}")
-            raise
-    
-    async def process_audio(self, audio_chunk: bytes) -> bool:
-        """Process audio chunk"""
-        if not self._loaded or self.model is None:
-            logger.warning("Model not loaded")
-            return False
-        
-        try:
-            import numpy as np
-            
-            # Convert audio to numpy array
-            audio_array = np.frombuffer(audio_chunk, dtype=np.int16).astype(np.float32) / 32768.0
-            
-            # Extract features
-            features = self.features.process_streaming(audio_array)
-            
-            # Process with model
-            for feature in features:
-                scores = self.model.process_streaming(feature)
-                for score in scores:
-                    self._confidence = score
-                    if score >= 0.5:  # Threshold
-                        logger.info(f"Wake word detected with confidence: {score:.2f}")
-                        return True
-            
-            return False
-        except Exception as e:
-            logger.error(f"Error processing audio: {e}")
-            return False
-    
-    async def get_confidence(self) -> float:
-        """Get detection confidence"""
-        return self._confidence
-
-
-async def load_wake_word_detector(
-    model_path: str,
-    detector_type: str = "micro"
-) -> WakeWordDetector:
-    """Load wake word detector based on type"""
-    if detector_type == "micro":
-        detector = MicroWakeWordDetector(model_path)
-    elif detector_type == "open":
-        detector = OpenWakeWordDetector(model_path)
-    else:
-        raise ValueError(f"Unknown detector type: {detector_type}")
-    
-    await detector.load_model(model_path)
-    return detector