future/smart-speaker
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update assistant features and docs

Browse Source
This commit is contained in:
future
2026-02-12 14:12:37 +03:00
parent bb3133a1c0
commit ca8ebd6657
19 changed files with 814 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.env.example
View File

@@ -2,6 +2,7 @@ PERPLEXITY_API_KEY=your_perplexity_api_key_here
PERPLEXITY_MODEL=llama-3.1-sonar-small-128k-chat
DEEPGRAM_API_KEY=your_deepgram_api_key_here
PORCUPINE_ACCESS_KEY=your_porcupine_access_key_here
PORCUPINE_SENSITIVITY=0.8
TTS_EN_SPEAKER=en_0
WEATHER_LAT=63.56
WEATHER_LON=53.69

10
Makefile Normal file
View File

@@ -0,0 +1,10 @@
.PHONY: run check qwen-context
run:
python run.py
check:
./scripts/qwen-check.sh
qwen-context:
./scripts/qwen-context.sh

32
QWEN.md Normal file
View File

@@ -0,0 +1,32 @@
# Qwen Context: alexander_smart-speaker
## Goal
Voice assistant for Linux with wake word, STT/TTS, AI dialogue, weather, timer/alarm/stopwatch and volume control.
## Architecture
- Entry: `run.py` -> `app/main.py`
- Audio layer: `app/audio/` (`wakeword.py`, `stt.py`, `tts.py`, `sound_level.py`)
- Core logic: `app/core/` (`commands.py`, `ai.py`, `config.py`, `cleaner.py`)
- Features: `app/features/` (weather, timer, stopwatch, alarm, music, cities game)
- State: `data/*.json`
## High-Value Files
- `app/core/commands.py` for intent routing
- `app/main.py` for event loop and orchestration
- `app/core/config.py` for env configuration
## How To Work In This Repo
1. Keep edits minimal and local.
2. Prefer fixes with clear fallback behavior (microphone/API failures).
3. Do not hardcode secrets; use `.env` and `.env.example`.
4. Update README when behavior/commands change.
## Quick Checks
```bash
./scripts/qwen-check.sh
```
## Notes For Agent
- If touching audio code, keep Linux compatibility first.
- For command parsing, add/adjust tests when test infra exists.
- Preserve Russian command phrases compatibility.

198
README.md
View File

@@ -1,146 +1,122 @@
# 🎙️ Alexander Smart Speaker
# Alexander Smart Speaker
<div align="center">
Голосовой ассистент для Linux с wake word, STT/TTS и набором голосовых навыков.
![Python](https://img.shields.io/badge/Python-3.9%2B-3776AB?logo=python&logoColor=white&style=for-the-badge)
![Platform](https://img.shields.io/badge/Platform-Linux-FCC624?logo=linux&logoColor=black&style=for-the-badge)
![License](https://img.shields.io/badge/License-MIT-45a163?style=for-the-badge)
## Что умеет
- Активация по ключевому слову `Alexandr`.
- Диалог с AI (Perplexity) с сохранением контекста.
- Перевод RU ↔ EN с озвучиванием.
- Погода по умолчанию и по названию города.
- Будильники, таймеры и секундомеры.
- Управление громкостью системы.
- Управление Spotify (play/pause/next/current track).
- Игра в города.
**Alexander** is a personal voice assistant for Linux that leverages modern AI technologies to create natural conversations. It listens, understands context, translates languages, checks the weather, and manages your time.
## Технологии
- Wake word: `pvporcupine`
- STT: `deepgram-sdk`
- TTS: `Silero` (`torch`, `torchaudio`)
- AI: Perplexity API
- Погода: Open-Meteo
- Музыка: Spotify Web API (`spotipy`)
[Features](#-features) • [Installation](#-installation) • [Usage](#-usage) • [Architecture](#-architecture)
## Требования
- Linux
- Python 3.9+
- Системные пакеты:
```bash
sudo apt-get update
sudo apt-get install -y portaudio19-dev libasound2-dev mpg123
```
Для управления громкостью нужен `pactl` или `amixer` (обычно из `pulseaudio-utils`/`alsa-utils`).
## Установка
</div>
---
## ✨ Features
### 🧠 Artificial Intelligence
* **Smart Dialogue**: Context-aware conversations powered by **Perplexity AI** (Llama 3.1).
* **Translator**: Instant bidirectional translation (RU ↔ EN) with native pronunciation.
### 🗣️ Voice Interface
* **Wake Word**: Activates on the phrase **"Alexander"** (powered by Porcupine).
* **Speech Recognition**: Fast and accurate Speech-to-Text via **Deepgram**.
* **Text-to-Speech**: Natural sounding offline voice synthesis using **Silero TTS**.
### 🛠️ Tools
* **⛅ Weather**: Detailed forecasts (current, daily range, hourly) via Open-Meteo.
* **⏰ Alarm & Timer**: Voice-controlled alarms and timers.
* **🔊 System Control**: Adjust system volume via voice commands.
---
## ⚙️ Installation
### 1. Prerequisites
* **OS**: Linux
* **Python**: 3.9+
* **System Libraries**:
```bash
sudo apt-get install portaudio19-dev libasound2-dev mpg123
```
### 2. Setup
```bash
# Clone the repository
git clone https://github.com/your-username/alexander_smart-speaker.git
cd alexander_smart-speaker
# Create virtual environment
python -m venv venv
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt
```
### 3. Configuration
Create a `.env` file based on the example:
## Настройка `.env`
```bash
cp .env.example .env
```
Fill in your API keys in `.env`:
Минимально обязательные переменные:
```ini
# AI & Speech APIs
PERPLEXITY_API_KEY=pplx-...
PERPLEXITY_API_KEY=...
DEEPGRAM_API_KEY=...
PORCUPINE_ACCESS_KEY=...
# TTS Settings
TTS_EN_SPEAKER=en_0
TTS_RU_SPEAKER=eugene
# Weather Location (Your City Coordinates)
WEATHER_LAT=63.56
WEATHER_LON=53.69
WEATHER_CITY=Ukhta
```
---
Полный пример (как в `.env.example`):
## 🚀 Usage
```ini
PERPLEXITY_API_KEY=your_perplexity_api_key_here
PERPLEXITY_MODEL=llama-3.1-sonar-small-128k-chat
DEEPGRAM_API_KEY=your_deepgram_api_key_here
PORCUPINE_ACCESS_KEY=your_porcupine_access_key_here
PORCUPINE_SENSITIVITY=0.8
TTS_EN_SPEAKER=en_0
WEATHER_LAT=63.56
WEATHER_LON=53.69
WEATHER_CITY=Ухта
SPOTIFY_CLIENT_ID=your_spotify_client_id
SPOTIFY_CLIENT_SECRET=your_spotify_client_secret
SPOTIFY_REDIRECT_URI=http://localhost:8888/callback
```
## Запуск
Start the assistant:
```bash
make run
# или
python run.py
```
### Command Examples
## Примеры голосовых команд
- Активация: `Alexandr`
- Диалог: `Почему небо голубое?`
- Погода: `Какая сейчас погода?`, `Погода в Москве`
- Перевод: `Переведи на английский: как дела`
- Таймер: `Поставь таймер на 5 минут`
- Будильник: `Поставь будильник на 7:30`, `Будильник по будням в 8:00`
- Секундомер: `Запусти секундомер`, `Покажи активные секундомеры`
- Громкость: `Громкость 5`
- Spotify: `Включи музыку`, `Пауза`, `Что сейчас играет`
- Игра: `Давай сыграем в города`
- Остановка/прерывание: `Стоп`, `Хватит`, `Повтори`
| Category | User Command (RU) | Action |
|----------|-------------------|--------|
| **Activation** | "Alexander" | Assistant starts listening |
| **Dialogue** | "Почему небо голубое?" | Ask AI with context retention |
| **Weather** | "Какая сейчас погода?", "Нужен ли зонт?" | Get weather forecast |
| **Translation** | "Переведи на английский: привет, как дела?" | Translate and speak in EN |
| **Alarm** | "Разбуди меня в 7:30", "Поставь таймер на 5 минут" | Set alarm or timer |
| **Volume** | "Громкость 5", "Громкость 8" | Set system volume level |
| **Control** | "Стоп", "Хватит", "Повтори" | Stop speech or repeat last phrase |
## Полезные команды
---
## 🏗️ Architecture
```mermaid
graph TD
Mic[🎤 Microphone] --> Wake[Wake Word<br/>Porcupine]
Wake -->|Activated| STT[STT<br/>Deepgram]
STT --> Router{Command Router}
Router -->|Forecast| Weather[⛅ Weather<br/>Open-Meteo]
Router -->|Time| Alarm[⏰ Alarm/Timer]
Router -->|Settings| Vol[🔊 Volume]
Router -->|Translate| Translator[A↔B Translator]
Router -->|Query| AI[🧠 Perplexity AI]
Weather --> TTS
Alarm --> TTS
Vol --> TTS
Translator --> TTS
AI --> Cleaner[Text Cleaner]
Cleaner --> TTS[🗣️ TTS<br/>Silero]
TTS --> Speaker[🔊 Speaker]
```bash
make run # запуск ассистента
make check # базовая проверка проекта
make qwen-context # собрать контекст проекта
```
## 📂 Project Structure
* `app/main.py` — Entry point, main event loop.
* `app/audio/` — Audio processing modules (STT, TTS, Wake Word).
* `app/core/` — AI logic, configuration, text cleaning.
* `app/features/` — Skills (Weather, Alarm, Timer).
* `assets/` — Models (Porcupine) and sound effects.
* `data/` — Persistent state (alarms).
## Структура проекта
- `run.py` - точка входа.
- `app/main.py` - главный цикл ассистента.
- `app/audio/` - wake word, STT, TTS, громкость.
- `app/core/` - конфиг, AI, роутинг команд, утилиты.
- `app/features/` - погода, будильник, таймер, секундомер, музыка, города.
- `assets/` - модели и звуки.
- `data/` - сохраненные будильники/таймеры/секундомеры.
---
## Диагностика проблем
- Ошибки STT/AI: проверьте ключи в `.env`.
- Нет звука: проверьте системное устройство вывода и утилиты `pactl`/`amixer`.
- Не играет будильник/таймер: убедитесь, что установлен `mpg123`.
- Spotify не управляется: проверьте `SPOTIFY_*`, авторизацию и наличие активного устройства.
## 🛠️ Troubleshooting
* **Deepgram Error 400**: Check your API key balance and validity in `.env`.
* **No Sound**: Ensure `amixer` is installed and the default audio output is correctly configured in your OS.
* **Alarm not playing**: Verify that `mpg123` is installed (`sudo apt install mpg123`).
## 📄 License
MIT License. See `LICENSE.txt` for details.
## Лицензия
MIT, см. `LICENSE.txt`.

3
app/audio/sound_level.py
View File

@@ -9,6 +9,7 @@ Regulates system volume on a scale from 1 to 10.
import subprocess
import re
import platform
from ..core.roman import replace_roman_numerals
# Карта для перевода слов в цифры ("пять" -> 5)
NUMBER_MAP = {
@@ -148,7 +149,7 @@ def parse_volume_text(text: str) -> int | None:
Пытается найти число громкости в тексте.
Понимает и цифры ("5"), и слова ("пять").
"""
text = text.lower()
text = replace_roman_numerals(text.lower())
# 1. Ищем цифры (1-10)
num_match = re.search(r"\b(10|[1-9])\b", text)

197
app/audio/stt.py
View File

@@ -8,6 +8,7 @@ Supports Russian (default) and English.
# Использует Deepgram API через веб-сокеты для потокового распознавания в реальном времени.
import asyncio
import re
import time
import pyaudio
import logging
@@ -24,16 +25,19 @@ import websockets.sync.client
from ..core.audio_manager import get_audio_manager
# --- Патч (исправление) для библиотеки websockets ---
# По умолчанию Deepgram SDK использует слишком короткий таймаут подключения.
# Это часто вызывает ошибки при медленном SSL рукопожатии.
# Мы подменяем функцию connect, чтобы увеличить таймаут до 30 секунд.
# Явно задаём таймауты подключения, чтобы не зависать на долгом handshake.
_original_connect = websockets.sync.client.connect
DEEPGRAM_CONNECT_TIMEOUT_SECONDS = 3.0
DEEPGRAM_CONNECT_WAIT_SECONDS = 1.5
DEEPGRAM_CONNECT_POLL_SECONDS = 0.001
def _patched_connect(*args, **kwargs):
kwargs.setdefault("open_timeout", 30)
kwargs.setdefault("ping_timeout", 30)
kwargs.setdefault("close_timeout", 30)
# Принудительно задаём короткие таймауты, даже если SDK передал свои (например, 30с).
kwargs["open_timeout"] = DEEPGRAM_CONNECT_TIMEOUT_SECONDS
kwargs["ping_timeout"] = DEEPGRAM_CONNECT_TIMEOUT_SECONDS
kwargs["close_timeout"] = DEEPGRAM_CONNECT_TIMEOUT_SECONDS
print(f"DEBUG: Connecting to Deepgram with timeout={kwargs.get('open_timeout')}s")
return _original_connect(*args, **kwargs)
@@ -44,6 +48,34 @@ sdk_ws.connect = _patched_connect
# Отключаем лишний мусор в логах
logging.getLogger("deepgram").setLevel(logging.WARNING)
# Базовые пороги для остановки STT
INITIAL_SILENCE_TIMEOUT_SECONDS = 5.0
POST_SPEECH_SILENCE_TIMEOUT_SECONDS = 3.0
# Длинный защитный предел, чтобы не обрывать обычную длинную фразу.
# Фактическое завершение происходит по 3 сек тишины после речи.
MAX_ACTIVE_SPEECH_SECONDS = 300.0
_FAST_STOP_UTTERANCE_RE = re.compile(
r"^(?:(?:александр|алесандр|alexander|alexandr)\s+)?"
r"(?:стоп|хватит|перестань|прекрати|замолчи|тихо|пауза)"
r"(?:\s+(?:пожалуйста|please))?$",
flags=re.IGNORECASE,
)
def _normalize_command_text(text: str) -> str:
normalized = text.lower().replace("ё", "е")
normalized = re.sub(r"[^\w\s]+", " ", normalized, flags=re.UNICODE)
normalized = re.sub(r"\s+", " ", normalized, flags=re.UNICODE).strip()
return normalized
def _is_fast_stop_utterance(text: str) -> bool:
normalized = _normalize_command_text(text)
if not normalized:
return False
return _FAST_STOP_UTTERANCE_RE.fullmatch(normalized) is not None
class SpeechRecognizer:
"""Класс распознавания речи через Deepgram."""
@@ -105,24 +137,42 @@ class SpeechRecognizer:
)
return self.stream
async def _process_audio(self, dg_connection, timeout_seconds, detection_timeout):
async def _process_audio(
self, dg_connection, timeout_seconds, detection_timeout, fast_stop
):
"""
Асинхронная функция для отправки аудио и получения текста.
Args:
dg_connection: Активное соединение с Deepgram.
timeout_seconds: Общее время прослушивания.
timeout_seconds: Аварийный лимит длительности активной речи.
detection_timeout: Время ожидания начала речи.
fast_stop: Если True, короткая стоп-фраза завершает STT после 1с тишины.
"""
self.transcript = ""
transcript_parts = []
loop = asyncio.get_running_loop()
stream = self._get_stream()
effective_detection_timeout = (
detection_timeout
if detection_timeout is not None
else INITIAL_SILENCE_TIMEOUT_SECONDS
)
# События для синхронизации
stop_event = asyncio.Event() # Пора останавливаться
speech_started_event = asyncio.Event() # Речь обнаружена (VAD)
last_speech_activity = time.monotonic()
first_speech_activity_at = None
def mark_speech_activity():
nonlocal last_speech_activity, first_speech_activity_at
now = time.monotonic()
last_speech_activity = now
if first_speech_activity_at is None:
first_speech_activity_at = now
speech_started_event.set()
# --- Обработчики событий Deepgram ---
def on_transcript(unused_self, result, **kwargs):
@@ -130,6 +180,20 @@ class SpeechRecognizer:
sentence = result.channel.alternatives[0].transcript
if len(sentence) == 0:
return
try:
loop.call_soon_threadsafe(mark_speech_activity)
except RuntimeError:
pass
if fast_stop:
if _is_fast_stop_utterance(sentence):
self.transcript = sentence.strip()
try:
loop.call_soon_threadsafe(stop_event.set)
except RuntimeError:
pass
return
if result.is_final:
# Собираем только финальные (подтвержденные) фразы
transcript_parts.append(sentence)
@@ -138,18 +202,16 @@ class SpeechRecognizer:
def on_speech_started(unused_self, speech_started, **kwargs):
"""Вызывается, когда VAD (Voice Activity Detection) слышит голос."""
try:
loop.call_soon_threadsafe(speech_started_event.set)
loop.call_soon_threadsafe(mark_speech_activity)
except RuntimeError:
# Event loop might be closed, ignore
pass
def on_utterance_end(unused_self, utterance_end, **kwargs):
"""Вызывается, когда Deepgram решает, что фраза закончилась (пауза)."""
try:
loop.call_soon_threadsafe(stop_event.set)
except RuntimeError:
# Event loop might be closed, ignore
pass
# Не останавливаемся мгновенно на событии Deepgram.
# Остановка управляется локальным порогом тишины POST_SPEECH_SILENCE_TIMEOUT_SECONDS.
return
def on_error(unused_self, error, **kwargs):
print(f"Deepgram Error: {error}")
@@ -174,10 +236,10 @@ class SpeechRecognizer:
channels=1,
sample_rate=SAMPLE_RATE,
interim_results=True,
utterance_end_ms=1000, # Пауза 1.0с считается концом фразы (было 1.2)
utterance_end_ms=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
vad_events=True,
# Добавляем параметры таймаута для долгой работы
endpointing=300, # Таймаут в миллисекундах для автоматического завершения
# Сглаженный порог endpointing, чтобы не резать речь на коротких паузах.
endpointing=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
)
# --- Задача отправки аудио с буферизацией ---
@@ -198,24 +260,29 @@ class SpeechRecognizer:
None, lambda: dg_connection.start(options)
)
# Пока подключаемся, копим данные
timeout_count = 0
max_timeout = 5000 # Максимальное количество итераций ожидания (около 2.5 секунд при 0.0005 задержке)
while not connect_future.done() and timeout_count < max_timeout:
# Пока подключаемся, копим данные.
# Ждём коротко: если сеть подвисла, быстрее перезапускаем попытку.
connect_deadline = time.monotonic() + DEEPGRAM_CONNECT_WAIT_SECONDS
while (
not connect_future.done()
and time.monotonic() < connect_deadline
):
if stream.is_active():
data = stream.read(4096, exception_on_overflow=False)
audio_buffer.append(data)
await asyncio.sleep(0.0005) # Уменьшаем задержку для более быстрой обработки
timeout_count += 1
await asyncio.sleep(DEEPGRAM_CONNECT_POLL_SECONDS)
if timeout_count >= max_timeout:
print("⏰ Timeout connecting to Deepgram")
if not connect_future.done():
print(
f"⏰ Timeout connecting to Deepgram ({DEEPGRAM_CONNECT_WAIT_SECONDS:.1f}s)"
)
stop_event.set()
return
# Проверяем результат подключения
if connect_future.result() is False:
print("Failed to start Deepgram connection")
stop_event.set()
return
print(f"🚀 Connected! Sending buffer ({len(audio_buffer)} chunks)...")
@@ -227,11 +294,8 @@ class SpeechRecognizer:
audio_buffer = None # Освобождаем память
# 4. Продолжаем стримить в реальном времени
stream_timeout = 0
max_stream_timeout = int(timeout_seconds / 0.002) # Примерный таймаут в зависимости от timeout_seconds
while not stop_event.is_set() and stream_timeout < max_stream_timeout:
# 4. Продолжаем стримить в реальном времени до события остановки.
while not stop_event.is_set():
if stream.is_active():
data = stream.read(4096, exception_on_overflow=False)
dg_connection.send(data)
@@ -239,7 +303,6 @@ class SpeechRecognizer:
if chunks_sent % 50 == 0:
print(".", end="", flush=True)
await asyncio.sleep(0.002) # Уменьшаем задержку для более быстрого реагирования
stream_timeout += 1
except Exception as e:
print(f"Audio send error: {e}")
@@ -255,19 +318,60 @@ class SpeechRecognizer:
try:
# 1. Ждем начала речи (если задан detection_timeout)
if detection_timeout:
if (
effective_detection_timeout
and effective_detection_timeout > 0
and not stop_event.is_set()
):
speech_wait_task = asyncio.create_task(speech_started_event.wait())
stop_wait_task = asyncio.create_task(stop_event.wait())
try:
await asyncio.wait_for(
speech_started_event.wait(), timeout=detection_timeout
done, pending = await asyncio.wait(
{speech_wait_task, stop_wait_task},
timeout=effective_detection_timeout,
return_when=asyncio.FIRST_COMPLETED,
)
except asyncio.TimeoutError:
finally:
for task in (speech_wait_task, stop_wait_task):
if not task.done():
task.cancel()
await asyncio.gather(
speech_wait_task, stop_wait_task, return_exceptions=True
)
if not done:
# Если за detection_timeout никто не начал говорить, выходим
stop_event.set()
# 2. Если речь началась (или таймаута нет), ждем завершения (stop_event)
# stop_event сработает либо по UtteranceEnd (пауза), либо по общему таймауту
# 2. После старта речи завершаем только по тишине POST_SPEECH_SILENCE_TIMEOUT_SECONDS.
# Добавляем длинный защитный лимит, чтобы сессия не зависла навсегда.
if not stop_event.is_set():
await asyncio.wait_for(stop_event.wait(), timeout=timeout_seconds)
max_active_speech_seconds = max(
timeout_seconds if timeout_seconds else 0.0,
MAX_ACTIVE_SPEECH_SECONDS,
)
while not stop_event.is_set():
now = time.monotonic()
if speech_started_event.is_set():
if (
now - last_speech_activity
>= POST_SPEECH_SILENCE_TIMEOUT_SECONDS
):
stop_event.set()
break
if (
first_speech_activity_at is not None
and now - first_speech_activity_at
>= max_active_speech_seconds
):
print("⏱️ Достигнут защитный лимит активного прослушивания.")
stop_event.set()
break
await asyncio.sleep(0.05)
except asyncio.TimeoutError:
pass # Общий таймаут вышел
@@ -291,16 +395,18 @@ class SpeechRecognizer:
def listen(
self,
timeout_seconds: float = 7.0,
detection_timeout: float = None,
detection_timeout: float = INITIAL_SILENCE_TIMEOUT_SECONDS,
lang: str = "ru",
fast_stop: bool = False,
) -> str:
"""
Основной метод: слушает микрофон и возвращает текст.
Args:
timeout_seconds: Максимальная длительность фразы.
timeout_seconds: Защитный лимит длительности активной речи.
detection_timeout: Сколько ждать начала речи перед тем как сдаться.
lang: Язык ("ru" или "en").
fast_stop: Быстрое завершение для коротких stop-команд.
"""
if not self.dg_client:
self.initialize()
@@ -323,7 +429,7 @@ class SpeechRecognizer:
# Запускаем асинхронный процесс обработки
transcript = asyncio.run(
self._process_audio(
dg_connection, timeout_seconds, detection_timeout
dg_connection, timeout_seconds, detection_timeout, fast_stop
)
)
final_text = transcript.strip() if transcript else ""
@@ -389,10 +495,13 @@ def get_recognizer() -> SpeechRecognizer:
def listen(
timeout_seconds: float = 7.0, detection_timeout: float = None, lang: str = "ru"
timeout_seconds: float = 7.0,
detection_timeout: float = INITIAL_SILENCE_TIMEOUT_SECONDS,
lang: str = "ru",
fast_stop: bool = False,
) -> str:
"""Внешняя функция для прослушивания."""
return get_recognizer().listen(timeout_seconds, detection_timeout, lang)
return get_recognizer().listen(timeout_seconds, detection_timeout, lang, fast_stop)
def cleanup():

12
app/audio/wakeword.py
View File

@@ -9,7 +9,11 @@ Listens for the "Alexandr" wake word.
import pvporcupine
import pyaudio
import struct
from ..core.config import PORCUPINE_ACCESS_KEY, PORCUPINE_KEYWORD_PATH
from ..core.config import (
PORCUPINE_ACCESS_KEY,
PORCUPINE_KEYWORD_PATH,
PORCUPINE_SENSITIVITY,
)
from ..core.audio_manager import get_audio_manager
@@ -27,13 +31,15 @@ class WakeWordDetector:
"""Инициализация Porcupine и PyAudio."""
# Создаем экземпляр Porcupine с нашим ключом доступа и файлом модели (.ppn)
self.porcupine = pvporcupine.create(
access_key=PORCUPINE_ACCESS_KEY, keyword_paths=[str(PORCUPINE_KEYWORD_PATH)]
access_key=PORCUPINE_ACCESS_KEY,
keyword_paths=[str(PORCUPINE_KEYWORD_PATH)],
sensitivities=[PORCUPINE_SENSITIVITY],
)
# Используем общий экземпляр PyAudio
self.pa = get_audio_manager().get_pyaudio()
self._open_stream()
print("🎤 Ожидание wake word 'Alexandr'...")
print(f"🎤 Ожидание wake word 'Alexandr' (sens={PORCUPINE_SENSITIVITY:.2f})...")
def _open_stream(self):
"""Открытие аудиопотока с микрофона."""

53
app/core/cleaner.py
View File

@@ -12,6 +12,7 @@ Handles complex number-to-text conversion for Russian language.
import re
import pymorphy3
from num2words import num2words
from .roman import roman_to_int
# Инициализация морфологического анализатора (для определения падежей)
morph = pymorphy3.MorphAnalyzer()
@@ -334,6 +335,50 @@ def numbers_to_words(text: str) -> str:
return text
def roman_numerals_to_words(text: str) -> str:
"""
Преобразует римские цифры в порядковые числительные с учетом
морфологии предыдущего слова.
Пример: "Ивана III" -> "Ивана третьего".
"""
if not text:
return ""
def replace_roman_match(match):
prev_word = match.group(1)
roman = match.group(2)
number = roman_to_int(roman)
if number is None:
return match.group(0)
case = "nominative"
gender = "m"
try:
parsed = morph.parse(prev_word)[0]
case_tag = parsed.tag.case
gender_tag = parsed.tag.gender
if case_tag:
case = PYMORPHY_TO_NUM2WORDS.get(case_tag, "nominative")
if gender_tag:
gender = PYMORPHY_TO_GENDER.get(gender_tag, "m")
except Exception:
pass
ordinal = convert_number(
str(number), context_type="ordinal", case=case, gender=gender
)
return f"{prev_word} {ordinal}"
return re.sub(
r"(?i)\b([А-Яа-яЁё]+)\s+([IVXLCDM]+)\b",
replace_roman_match,
text,
)
def clean_response(text: str, language: str = "ru") -> str:
"""
Основная функция очистки.
@@ -408,9 +453,11 @@ def clean_response(text: str, language: str = "ru") -> str:
flags=re.IGNORECASE | re.MULTILINE,
)
# Convert numbers to words only for Russian, and only if digits exist
if language == "ru" and re.search(r"\d", text):
text = numbers_to_words(text)
# Convert Roman numerals and Arabic digits to words for Russian.
if language == "ru":
text = roman_numerals_to_words(text)
if re.search(r"\d", text):
text = numbers_to_words(text)
# Remove extra whitespace
text = re.sub(r"\n{3,}", "\n\n", text)

2
app/core/config.py
View File

@@ -33,6 +33,8 @@ DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY")
PORCUPINE_ACCESS_KEY = os.getenv("PORCUPINE_ACCESS_KEY")
# Путь к файлу модели ключевого слова (.ppn), который лежит в папке assets/models
PORCUPINE_KEYWORD_PATH = BASE_DIR / "assets" / "models" / "Alexandr_en_linux_v4_0_0.ppn"
# Чувствительность wake word (0..1). Выше = ловит легче, но больше ложных срабатываний.
PORCUPINE_SENSITIVITY = float(os.getenv("PORCUPINE_SENSITIVITY", "0.8"))
# --- Параметры аудио ---
# Частота дискретизации для микрофона (стандарт для распознавания речи)

43
app/core/roman.py Normal file
View File

@@ -0,0 +1,43 @@
"""Roman numeral parsing helpers."""
import re
_ROMAN_VALID_RE = re.compile(
r"^M{0,3}(CM|CD|D?C{0,3})"
r"(XC|XL|L?X{0,3})"
r"(IX|IV|V?I{0,3})$"
)
_ROMAN_TOKEN_RE = re.compile(r"(?<![A-Za-zА-Яа-яЁё0-9])[IVXLCDMivxlcdm]+(?![A-Za-zА-Яа-яЁё0-9])")
_ROMAN_VALUES = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
def roman_to_int(token: str) -> int | None:
if not token:
return None
roman = token.strip().upper()
if not roman or not _ROMAN_VALID_RE.fullmatch(roman):
return None
total = 0
prev = 0
for char in reversed(roman):
value = _ROMAN_VALUES[char]
if value < prev:
total -= value
else:
total += value
prev = value
return total
def replace_roman_numerals(text: str) -> str:
if not text:
return text
def _repl(match: re.Match) -> str:
token = match.group(0)
value = roman_to_int(token)
return str(value) if value is not None else token
return _ROMAN_TOKEN_RE.sub(_repl, text)

12
app/features/alarm.py
View File

@@ -10,11 +10,13 @@ from datetime import datetime
from ..core.config import BASE_DIR
from ..audio.stt import listen
from ..core.commands import is_stop_command
from ..core.roman import replace_roman_numerals
# Файл базы данных будильников
ALARM_FILE = BASE_DIR / "data" / "alarms.json"
# Звуковой файл сигнала
ALARM_SOUND = BASE_DIR / "assets" / "sounds" / "Apex-1.mp3"
ASK_ALARM_TIME_PROMPT = "На какое время мне поставить будильник?"
class AlarmClock:
@@ -229,7 +231,7 @@ class AlarmClock:
try:
# Цикл ожидания стоп-команды
while True:
text = listen(timeout_seconds=3.0, detection_timeout=3.0)
text = listen(timeout_seconds=3.0, detection_timeout=3.0, fast_stop=True)
if text:
if is_stop_command(text, mode="lenient"):
print(f"🛑 Будильник остановлен по команде: '{text}'")
@@ -251,7 +253,7 @@ class AlarmClock:
Парсинг команды установки будильника из текста.
Примеры: "разбуди в 7:30", "будильник на 8 утра".
"""
text = text.lower()
text = replace_roman_numerals(text.lower())
if "будильник" not in text and "разбуди" not in text:
return None
@@ -299,6 +301,12 @@ class AlarmClock:
suffix = f" {days_phrase}" if days_phrase else ""
return f"Хорошо, разбужу вас в {h}:{m:02d}{suffix}."
if re.search(r"(постав|установ|запусти|включи|разбуди)", text) or text.strip() in {
"будильник",
"поставь будильник",
}:
return ASK_ALARM_TIME_PROMPT
return "Я не понял время для будильника. Пожалуйста, скажите точное время, например 'семь тридцать'."

11
app/features/music.py
View File

@@ -9,6 +9,7 @@ Spotify Music Controller
- "следующий трек" / "next" - следующий трек
- "предыдущий трек" / "previous" - предыдущий трек
- "что играет" / "какая песня" - информация о текущем треке
- "угадай песню" / "распознай музыку" - распознавание текущего трека
"""
import os
@@ -287,6 +288,16 @@ class SpotifyMusicController:
if re.search(pattern, text_lower) and ("трек" in text_lower or "песн" in text_lower or "previous" in text_lower or "back" in text_lower):
return self.previous_track()
# Явные команды распознавания музыки (типа "угадай песню")
recognize_patterns = [
r"((александр|александра|алесандр|alexander)\s+)?(угадай|распознай|определи)\s+(мелод|музык|песн|трек)",
r"((александр|александра|алесандр|alexander)\s+)?(что за|какая это)\s+(музык|песн|трек)",
r"(identify|recognize)\s+(song|music|track)",
]
for pattern in recognize_patterns:
if re.search(pattern, text_lower):
return self.get_current_track()
# Что играет
current_patterns = [
r"(что (сейчас )?играет|как(ая|ой) (песня|трек)|что за (песня|трек|музыка))",

267
app/features/stopwatch.py Normal file
View File

@@ -0,0 +1,267 @@
"""Stopwatch module."""
import json
import re
from datetime import datetime
from ..core.config import BASE_DIR
STOPWATCH_FILE = BASE_DIR / "data" / "stopwatches.json"
# Optional ordinal formatting for list numbering.
try:
from num2words import num2words
except Exception:
num2words = None
def _format_ordinal_index(index: int) -> str:
if num2words is None:
return f"{index}-й"
try:
return num2words(index, lang="ru", to="ordinal", case="nominative", gender="m")
except Exception:
return f"{index}-й"
def _format_duration(seconds: float) -> str:
total = int(round(max(0, seconds)))
hours = total // 3600
minutes = (total % 3600) // 60
sec = total % 60
parts = []
if hours:
parts.append(f"{hours} ч")
if minutes:
parts.append(f"{minutes} мин")
parts.append(f"{sec} сек")
return " ".join(parts)
class StopwatchManager:
def __init__(self):
self.stopwatches = []
self.load_stopwatches()
def load_stopwatches(self):
if not STOPWATCH_FILE.exists():
return
try:
with open(STOPWATCH_FILE, "r", encoding="utf-8") as f:
raw = json.load(f)
except Exception as e:
print(f"❌ Ошибка загрузки секундомеров: {e}")
return
items = []
for item in raw:
try:
stopwatch_id = int(item["id"])
except Exception:
continue
items.append(
{
"id": stopwatch_id,
"name": str(item.get("name", "")).strip(),
"elapsed": float(item.get("elapsed", 0)),
"running": bool(item.get("running", False)),
"started_at": item.get("started_at"),
}
)
self.stopwatches = sorted(items, key=lambda x: x["id"])
def save_stopwatches(self):
payload = [
{
"id": sw["id"],
"name": sw.get("name", ""),
"elapsed": sw.get("elapsed", 0),
"running": sw.get("running", False),
"started_at": sw.get("started_at"),
}
for sw in self.stopwatches
]
try:
with open(STOPWATCH_FILE, "w", encoding="utf-8") as f:
json.dump(payload, f, indent=4)
except Exception as e:
print(f"❌ Ошибка сохранения секундомеров: {e}")
def _next_id(self) -> int:
if not self.stopwatches:
return 1
return max(sw["id"] for sw in self.stopwatches) + 1
def _now_iso(self) -> str:
return datetime.now().isoformat()
def _elapsed_now(self, stopwatch: dict) -> float:
elapsed = float(stopwatch.get("elapsed", 0))
if not stopwatch.get("running"):
return elapsed
started_at = stopwatch.get("started_at")
if not started_at:
return elapsed
try:
started_dt = datetime.fromisoformat(started_at)
except Exception:
return elapsed
delta = (datetime.now() - started_dt).total_seconds()
return elapsed + max(0, delta)
def _running(self):
return [sw for sw in self.stopwatches if sw.get("running")]
def _paused(self):
return [sw for sw in self.stopwatches if not sw.get("running")]
def has_running_stopwatches(self) -> bool:
return bool(self._running())
def describe_active_stopwatches(self) -> str:
running = self._running()
if not running:
return "Активных секундомеров нет."
running.sort(key=lambda sw: sw["id"])
items = []
for idx, sw in enumerate(running, start=1):
ordinal = _format_ordinal_index(idx)
duration = _format_duration(self._elapsed_now(sw))
name = sw.get("name", "")
if name:
items.append(f"{ordinal}) {name} — {duration}")
else:
items.append(f"{ordinal}) {duration}")
return "Активные секундомеры: " + "; ".join(items) + "."
def start_stopwatch(self, name: str = "") -> str:
stopwatch = {
"id": self._next_id(),
"name": name.strip(),
"elapsed": 0.0,
"running": True,
"started_at": self._now_iso(),
}
self.stopwatches.append(stopwatch)
self.save_stopwatches()
if stopwatch["name"]:
return f"Запустил секундомер «{stopwatch['name']}»."
return "Запустил секундомер."
def pause_stopwatches(self) -> str:
running = self._running()
if not running:
return "Сейчас нет активных секундомеров."
elapsed_items = []
for sw in running:
elapsed_now = self._elapsed_now(sw)
elapsed_items.append(
{
"id": sw["id"],
"name": sw.get("name", ""),
"elapsed": elapsed_now,
}
)
sw["elapsed"] = elapsed_now
sw["running"] = False
sw["started_at"] = None
self.save_stopwatches()
count = len(running)
if count == 1:
elapsed_text = _format_duration(elapsed_items[0]["elapsed"])
return f"Остановил секундомер. Он работал {elapsed_text}."
details = []
for idx, item in enumerate(sorted(elapsed_items, key=lambda x: x["id"]), start=1):
ordinal = _format_ordinal_index(idx)
elapsed_text = _format_duration(item["elapsed"])
name = item.get("name", "")
if name:
details.append(f"{ordinal} «{name}» — {elapsed_text}")
else:
details.append(f"{ordinal} — {elapsed_text}")
return f"Остановил секундомеры: {count} шт. Время: " + "; ".join(details) + "."
def resume_stopwatches(self) -> str:
paused = self._paused()
if not paused:
return "Пауза не активна: секундомеры уже запущены или отсутствуют."
for sw in paused:
sw["running"] = True
sw["started_at"] = self._now_iso()
self.save_stopwatches()
count = len(paused)
if count == 1:
return "Продолжил секундомер."
return f"Продолжил секундомеры: {count} шт."
def reset_stopwatches(self) -> str:
if not self.stopwatches:
return "Секундомеров для сброса нет."
count = len(self.stopwatches)
self.stopwatches = []
self.save_stopwatches()
if count == 1:
return "Секундомер сброшен."
return f"Сбросил секундомеры: {count} шт."
def parse_command(self, text: str) -> str | None:
text = text.lower().strip()
has_stopwatch_word = any(
word in text
for word in [
"секундомер",
"секундомеры",
"секундомером",
"секундомера",
"секундомеру",
]
)
if not has_stopwatch_word:
return None
if re.search(r"(какие|какой|список|активн|покажи|сколько|есть ли)", text):
return self.describe_active_stopwatches()
if any(word in text for word in ["сброс", "удали", "отмени", "очист"]):
return self.reset_stopwatches()
if any(word in text for word in ["продолж", "возобнов"]):
return self.resume_stopwatches()
if any(word in text for word in ["стоп", "останов", "пауза"]):
return self.pause_stopwatches()
if "постав" in text or "установ" in text:
return self.start_stopwatch()
if any(word in text for word in ["запусти", "включи", "старт", "начни"]):
return self.start_stopwatch()
# Если пользователь просто сказал "секундомер", трактуем как запуск.
if text in {"секундомер", "запусти секундомер", "включи секундомер"}:
return self.start_stopwatch()
return "Я понял команду про секундомер, но не распознал действие. Скажите: запусти, стоп, продолжи, сбрось или покажи активные секундомеры."
_stopwatch_manager = None
def get_stopwatch_manager():
global _stopwatch_manager
if _stopwatch_manager is None:
_stopwatch_manager = StopwatchManager()
return _stopwatch_manager

17
app/features/timer.py
View File

@@ -10,6 +10,7 @@ from datetime import datetime, timedelta
from ..core.config import BASE_DIR
from ..audio.stt import listen
from ..core.commands import is_stop_command
from ..core.roman import replace_roman_numerals
# Morphological analysis for better recognition of number words.
try:
@@ -22,6 +23,7 @@ except Exception:
# Звуковой файл сигнала (используем тот же, что и для будильника)
ALARM_SOUND = BASE_DIR / "assets" / "sounds" / "Apex-1.mp3"
TIMER_FILE = BASE_DIR / "data" / "timers.json"
ASK_TIMER_TIME_PROMPT = "На какое время мне поставить таймер?"
# --- Number words parsing helpers (ru) ---
_NUMBER_UNITS = {
@@ -162,11 +164,13 @@ def _parse_number_lemmas(lemmas):
def _normalize_timer_text(text: str) -> str:
# Split "полчаса/полминуты/полсекунды" into "пол часа" for easier parsing.
return re.sub(
text = re.sub(
r"(?i)\bпол(?=(?:час|часа|минут|минуты|минуту|секунд|секунды|секунду|мин|сек)\b)",
"пол ",
text,
)
# Support commands like "таймер на X минут".
return replace_roman_numerals(text)
def _find_word_number_before_unit(tokens, unit_index):
@@ -371,7 +375,7 @@ class TimerManager:
try:
# Цикл ожидания стоп-команды
while True:
text = listen(timeout_seconds=3.0, detection_timeout=3.0)
text = listen(timeout_seconds=3.0, detection_timeout=3.0, fast_stop=True)
if text:
if is_stop_command(text, mode="lenient"):
print(f"🛑 Таймер остановлен по команде: '{text}'")
@@ -477,7 +481,14 @@ class TimerManager:
self.add_timer(total_seconds, label)
return f"Поставил таймер на {label}."
# Если сказали "таймер", но не нашли время
# Если попросили поставить таймер, но не назвали время — задаем уточняющий вопрос.
if re.search(r"(постав|установ|запусти|включи|засеки)", text) or text.strip() in {
"таймер",
"поставь таймер",
}:
return ASK_TIMER_TIME_PROMPT
# Если сказали "таймер", но не нашли время.
return "Я не понял, на сколько поставить таймер. Скажите, например, 'таймер на 5 минут'."

71
app/main.py
View File

@@ -53,8 +53,9 @@ from .core.config import BASE_DIR
from .core.cleaner import clean_response
from .core.commands import is_stop_command
from .core.smalltalk import get_smalltalk_response
from .features.alarm import get_alarm_clock
from .features.timer import get_timer_manager
from .features.alarm import ASK_ALARM_TIME_PROMPT, get_alarm_clock
from .features.stopwatch import get_stopwatch_manager
from .features.timer import ASK_TIMER_TIME_PROMPT, get_timer_manager
from .features.weather import get_weather_report
from .features.music import get_music_controller
from .features.cities_game import get_cities_game
@@ -256,6 +257,7 @@ def main():
get_recognizer().initialize() # Подключение к Deepgram
init_tts() # Загрузка нейросети для синтеза речи (Silero)
alarm_clock = get_alarm_clock() # Загрузка будильников
stopwatch_manager = get_stopwatch_manager() # Загрузка секундомеров
timer_manager = get_timer_manager() # Загрузка таймеров
cities_game = get_cities_game() # Игра "Города"
print()
@@ -270,6 +272,10 @@ def main():
# (True = режим диалога, слушаем сразу. False = ждем "Alexandr")
skip_wakeword = False
# Контекст уточнения "на какое время поставить ...".
# Может быть: "timer", "alarm".
pending_time_target = None
# Переменная для отслеживания последней проверки здоровья STT
last_stt_check = time.time()
@@ -314,9 +320,10 @@ def main():
if ding_sound:
ding_sound.play()
# Фраза услышана! Слушаем команду пользователя (5 секунд тишины макс)
# Фраза активации услышана:
# до 5с ждём начало речи, после начала завершаем STT по 3с тишины.
try:
user_text = listen(timeout_seconds=5.0)
user_text = listen(timeout_seconds=5.0, fast_stop=True)
except Exception as e:
print(f"Ошибка при прослушивании: {e}")
print("Переинициализация STT...")
@@ -328,10 +335,12 @@ def main():
continue # Продолжаем цикл
else:
# Режим диалога (Follow-up): ждем продолжения речи без "Alexandr"
print("👂 Слушаю продолжение диалога (3 сек)...")
# Ждем начала речи 3 сек. Если начали говорить, слушаем до 7 сек.
print("👂 Слушаю продолжение диалога (5 сек)...")
# Ждем начала речи 5 сек. Если начали говорить, слушаем до 7 сек.
try:
user_text = listen(timeout_seconds=7.0, detection_timeout=3.0)
user_text = listen(
timeout_seconds=7.0, detection_timeout=5.0, fast_stop=True
)
except Exception as e:
print(f"Ошибка при прослушивании: {e}")
print("Переинициализация STT...")
@@ -350,13 +359,21 @@ def main():
# --- Шаг 2: Анализ распознанного текста ---
if not user_text:
# Была активация, но речь не распознана
speak("Извините, я вас не расслышал. Попробуйте ещё раз.")
skip_wakeword = False # Возвращаемся в режим ожидания имени
# Пустой ввод: без лишних ответов возвращаемся к ожиданию wake word.
skip_wakeword = False
continue
# Проверка на команду "Стоп"
if is_stop_command(user_text):
if stopwatch_manager.has_running_stopwatches():
stopwatch_stop_response = stopwatch_manager.pause_stopwatches()
clean_stopwatch_stop_response = clean_response(
stopwatch_stop_response, language="ru"
)
speak(clean_stopwatch_stop_response)
last_response = clean_stopwatch_stop_response
skip_wakeword = False
continue
print("_" * 50)
print("💤 Жду 'Alexandr' для активации...")
skip_wakeword = False
@@ -387,24 +404,52 @@ def main():
skip_wakeword = True
continue
command_text = user_text
command_text_lower = command_text.lower()
if pending_time_target == "timer" and "таймер" not in command_text_lower:
command_text = f"таймер {command_text}"
elif (
pending_time_target == "alarm"
and "будильник" not in command_text_lower
and "разбуди" not in command_text_lower
):
command_text = f"будильник {command_text}"
# Проверка команд таймера ("поставь таймер на 6 минут")
timer_response = timer_manager.parse_command(user_text)
stopwatch_response = stopwatch_manager.parse_command(command_text)
if stopwatch_response:
clean_stopwatch_response = clean_response(
stopwatch_response, language="ru"
)
speak(clean_stopwatch_response)
last_response = clean_stopwatch_response
skip_wakeword = True
continue
# Проверка команд таймера ("поставь таймер на 6 минут")
timer_response = timer_manager.parse_command(command_text)
if timer_response:
clean_timer_response = clean_response(timer_response, language="ru")
completed = speak(
clean_timer_response, check_interrupt=check_wakeword_once
)
last_response = clean_timer_response
pending_time_target = (
"timer" if timer_response == ASK_TIMER_TIME_PROMPT else None
)
skip_wakeword = not completed
continue
# Проверка команд будильника ("поставь будильник на 7")
alarm_response = alarm_clock.parse_command(user_text)
alarm_response = alarm_clock.parse_command(command_text)
if alarm_response:
clean_alarm_response = clean_response(alarm_response, language="ru")
speak(clean_alarm_response)
last_response = clean_alarm_response
skip_wakeword = False
pending_time_target = (
"alarm" if alarm_response == ASK_ALARM_TIME_PROMPT else None
)
skip_wakeword = alarm_response == ASK_ALARM_TIME_PROMPT
continue
# Проверка команды громкости ("громкость 5")

9
data/stopwatches.json Normal file
View File

@@ -0,0 +1,9 @@
[
{
"id": 1,
"name": "",
"elapsed": 92.426419,
"running": false,
"started_at": null
}
]

24
scripts/qwen-check.sh Executable file
View File

@@ -0,0 +1,24 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT"
echo "[qwen-check] Python syntax compile check"
python -m compileall app run.py >/dev/null
echo "[qwen-check] Optional ruff check"
if command -v ruff >/dev/null 2>&1; then
ruff check app run.py
else
echo "[qwen-check] ruff not installed, skipping"
fi
echo "[qwen-check] Optional pytest"
if command -v pytest >/dev/null 2>&1 && [ -d tests ]; then
pytest -q
else
echo "[qwen-check] tests/ or pytest not found, skipping"
fi
echo "[qwen-check] Done"

22
scripts/qwen-context.sh Executable file
View File

@@ -0,0 +1,22 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
OUT="$ROOT/.qwen/project-context.txt"
{
echo "Project: alexander_smart-speaker"
echo "Generated: $(date -Iseconds)"
echo
echo "Top-level files:"
find "$ROOT" -maxdepth 2 -type f \
! -path '*/.git/*' \
! -path '*/venv/*' \
! -path '*/__pycache__/*' \
| sed "s|$ROOT/||" | sort
echo
echo "Python modules:"
find "$ROOT/app" -type f -name '*.py' | sed "s|$ROOT/||" | sort
} > "$OUT"
echo "[qwen-context] Wrote $OUT"

10
ssp.py Normal file
View File

@@ -0,0 +1,10 @@
maxi = 0
for i in range(84052, 84131):
k = 0
for j in range(1, i + 1):
if i % j == 0:
k += 1
if maxi < k:
maxi = k
f = i
print(maxi, f)