Ultrasonic Agentics

from agentic_commands_stego.decode.audio_decoder import AudioDecoder
import pyaudio
import numpy as np
import threading
import time

class UltrasonicListener:
    """Класс для прослушивания ультразвуковых команд в реальном времени"""
    
    def __init__(self, key: bytes):
        self.decoder = AudioDecoder(key=key)
        self.is_listening = False
        self.audio_stream = None
        self.command_handlers = {}
        
    def register_command_handler(self, command_prefix: str, handler_func):
        """Регистрация обработчика для команд с определенным префиксом"""
        self.command_handlers[command_prefix] = handler_func
    
    def on_command_detected(self, command: str):
        """Обработка обнаруженной команды"""
        print(f"🎯 Обнаружена команда: {command}")
        
        # Поиск подходящего обработчика
        for prefix, handler in self.command_handlers.items():
            if command.startswith(prefix):
                try:
                    handler(command)
                    return
                except Exception as e:
                    print(f"❌ Ошибка при выполнении команды: {e}")
                    
        print(f"⚠️ Не найден обработчик для команды: {command}")
    
    def start_listening(self, device_index=None):
        """Начало прослушивания микрофона"""
        self.is_listening = True
        
        # Настройка PyAudio
        p = pyaudio.PyAudio()
        
        # Параметры аудиопотока
        chunk_size = 1024
        sample_rate = 44100
        channels = 1
        
        try:
            self.audio_stream = p.open(
                format=pyaudio.paFloat32,
                channels=channels,
                rate=sample_rate,
                input=True,
                input_device_index=device_index,
                frames_per_buffer=chunk_size
            )
            
            print("🎤 Начато прослушивание ультразвуковых команд...")
            print("Нажмите Ctrl+C для остановки")
            
            # Буфер для накопления аудиоданных
            audio_buffer = np.array([])
            buffer_duration = 2.0  # секунды
            buffer_size = int(sample_rate * buffer_duration)
            
            while self.is_listening:
                # Чтение аудиоданных
                data = self.audio_stream.read(chunk_size, exception_on_overflow=False)
                audio_chunk = np.frombuffer(data, dtype=np.float32)
                
                # Добавление в буфер
                audio_buffer = np.append(audio_buffer, audio_chunk)
                
                # Ограничение размера буфера
                if len(audio_buffer) > buffer_size:
                    audio_buffer = audio_buffer[-buffer_size:]
                
                # Попытка декодирования каждые 0.5 секунды
                if len(audio_buffer) >= sample_rate // 2:
                    try:
                        command = self.decoder.decode_audio_data(
                            audio_buffer, 
                            sample_rate=sample_rate
                        )
                        if command:
                            self.on_command_detected(command)
                            # Очистка буфера после успешного декодирования
                            audio_buffer = np.array([])
                    except:
                        pass  # Игнорируем ошибки декодирования
                        
        except KeyboardInterrupt:
            print("\n🛑 Остановка прослушивания...")
        finally:
            self.stop_listening()
            p.terminate()
    
    def stop_listening(self):
        """Остановка прослушивания"""
        self.is_listening = False
        if self.audio_stream:
            self.audio_stream.stop_stream()
            self.audio_stream.close()

# Пример использования
def handle_execute_command(command: str):
    """Обработчик команд execute"""
    action = command.replace("execute:", "").strip()
    print(f"🚀 Выполнение действия: {action}")
    # Здесь может быть логика выполнения команды

def handle_status_command(command: str):
    """Обработчик команд статуса"""
    print(f"📊 Запрос статуса: {command}")
    # Здесь может быть логика получения статуса

if __name__ == "__main__":
    # Создание ключа (тот же, что использовался для встраивания)
    key = create_secure_key("my_secure_password_123")
    
    # Создание слушателя
    listener = UltrasonicListener(key)
    
    # Регистрация обработчиков команд
    listener.register_command_handler("execute:", handle_execute_command)
    listener.register_command_handler("status:", handle_status_command)
    
    # Начало прослушивания
    listener.start_listening()

# ML-улучшенный декодер
from agentic_commands_stego.ml import MLEnhancedDecoder, NoiseProfiler
import numpy as np
from sklearn.ensemble import RandomForestClassifier

class IntelligentDecoder:
    def __init__(self, key: bytes):
        self.base_decoder = AudioDecoder(key=key)
        self.ml_decoder = MLEnhancedDecoder(key=key)
        self.noise_profiler = NoiseProfiler()
        self.confidence_threshold = 0.8
        
    def decode_with_ml_enhancement(self, audio_file: str) -> dict:
        """Декодирование с ML-улучшениями"""
        
        result = {
            'command': None,
            'confidence': 0.0,
            'method': None,
            'noise_profile': None,
            'recommendations': []
        }
        
        # Анализ шумового профиля
        noise_profile = self.noise_profiler.analyze_file(audio_file)
        result['noise_profile'] = noise_profile
        
        # Выбор стратегии декодирования на основе шума
        if noise_profile['snr'] > 20:  # Высокое качество
            # Стандартное декодирование
            command = self.base_decoder.decode_file(audio_file)
            confidence = 0.95 if command else 0.0
            method = 'standard'
            
        elif noise_profile['snr'] > 10:  # Среднее качество
            # ML-улучшенное декодирование
            command, confidence = self.ml_decoder.decode_with_confidence(audio_file)
            method = 'ml_enhanced'
            
        else:  # Низкое качество
            # Агрессивная ML-обработка
            command, confidence = self.ml_decoder.decode_aggressive(audio_file)
            method = 'ml_aggressive'
        
        result['command'] = command if confidence > self.confidence_threshold else None
        result['confidence'] = confidence
        result['method'] = method
        
        # Генерация рекомендаций
        result['recommendations'] = self._generate_recommendations(noise_profile, confidence)
        
        return result
    
    def _generate_recommendations(self, noise_profile: dict, confidence: float) -> list:
        """Генерация рекомендаций по улучшению"""
        
        recommendations = []
        
        if noise_profile['snr'] < 15:
            recommendations.append("Используйте шумоподавление перед декодированием")
        
        if confidence < 0.6:
            recommendations.append("Попробуйте увеличить амплитуду сигнала")
        
        if noise_profile['has_high_freq_noise']:
            recommendations.append("Примените фильтр высоких частот")
        
        if noise_profile['background_music']:
            recommendations.append("Рассмотрите использование других частот")
        
        return recommendations
    
    def train_on_custom_data(self, training_data: list):
        """Обучение на пользовательских данных"""
        
        print("🎓 Начинаем обучение ML модели...")
        
        features = []
        labels = []
        
        for data_point in training_data:
            # Извлечение признаков из аудио
            audio_features = self._extract_features(data_point['audio'])
            features.append(audio_features)
            labels.append(data_point['has_command'])
        
        # Обучение классификатора
        classifier = RandomForestClassifier(n_estimators=100, random_state=42)
        classifier.fit(np.array(features), labels)
        
        # Обновление ML декодера
        self.ml_decoder.update_classifier(classifier)
        
        print("✅ Обучение завершено")
    
    def _extract_features(self, audio_data: np.ndarray) -> list:
        """Извлечение признаков из аудиоданных"""
        
        features = []
        
        # Спектральные признаки
        fft = np.fft.fft(audio_data)
        spectrum = np.abs(fft)
        
        # Энергия в целевых частотах (18-20 кГц)
        target_freq_energy = np.sum(spectrum[18000:20000])
        features.append(target_freq_energy)
        
        # Общая энергия сигнала
        total_energy = np.sum(spectrum)
        features.append(total_energy)
        
        # Отношение энергий
        if total_energy > 0:
            features.append(target_freq_energy / total_energy)
        else:
            features.append(0)
        
        # Пиковая частота
        peak_freq = np.argmax(spectrum)
        features.append(peak_freq)
        
        # Спектральная энтропия
        normalized_spectrum = spectrum / np.sum(spectrum)
        entropy = -np.sum(normalized_spectrum * np.log2(normalized_spectrum + 1e-10))
        features.append(entropy)
        
        return features

# Пример использования интеллектуального декодера
decoder = IntelligentDecoder(encryption_key)

# Декодирование с ML-улучшениями
result = decoder.decode_with_ml_enhancement("noisy_audio.mp3")

print(f"Команда: {result['command']}")
print(f"Уверенность: {result['confidence']:.2f}")
print(f"Метод: {result['method']}")
print(f"SNR: {result['noise_profile']['snr']:.1f} дБ")

if result['recommendations']:
    print("Рекомендации:")
    for rec in result['recommendations']:
        print(f"  • {rec}")

# Обучение на пользовательских данных (опционально)
# training_data = [
#     {'audio': audio_sample_1, 'has_command': True},
#     {'audio': audio_sample_2, 'has_command': False},
#     # ... больше данных
# ]
# decoder.train_on_custom_data(training_data)