Upload 3 files

README.md

@@ -9,14 +9,17 @@ pinned: false
 
 FastAPI-сервис для Hugging Face Docker Space, который заменяет тяжёлый Qwen TTS на более лёгкий CPU-стек:
 
-- `POST /podcast-script` — LLM-сценарист подкаста строго по фактам маршрута.
-- `POST /tts` — короткая русская озвучка через Piper.
+- `POST /podcast-script` — быстрый фактологический сценарий по данным маршрута; LLM можно включить отдельно на более мощном hardware.
+- `POST /tts` — русская озвучка через Piper, по умолчанию женским голосом `ru_RU-irina-medium`; длинная допустимая реплика синтезируется полностью.
 
 ## Что важно
 
 - Space остаётся тем же: можно обновить файлы существующего `menhaus-velosearch`.
-- Цель v1 — стабильность на CPU Space, а не максимальная натуральность голоса.
+- Цель v1 — стабильность на бесплатном CPU Space, поэтому по умолчанию подкаст собирается шаблонно по фактам без ожидания LLM.
 - LLM не должна выдумывать факты: prompt требует использовать только данные из запроса.
+- Основной голос аудиогида — женский Piper `ru_RU-irina-medium`; `ru_RU-dmitri-medium` оставлен в allowlist как технический fallback.
+- Перед Piper применяется произносительная нормализация: адресные формы (`г.`, `ул.`, `д.`) и единицы маршрута раскрываются для речи, не изменяя исходные данные приложения.
+- Реплика длиннее внутреннего чанка синтезируется по частям и возвращается одним WAV/OGG-файлом, поэтому клиент получает одно событие завершения речи.
 - На момент проверки репозиторий `rhasspy/piper-voices` указывает лицензию MIT, но для релиза стоит сохранить ссылку на карточку и файл лицензии выбранного голоса.
 - Если LLM или TTS недоступны, клиент должен использовать шаблонный подкаст и браузерный голос.
 
@@ -30,11 +33,13 @@ FastAPI-сервис для Hugging Face Docker Space, который замен
 | `PODCAST_LLM_MAX_FACTS` | `4` | Максимум точек маршрута в одном сценарии |
 | `PODCAST_LLM_MAX_INPUT_CHARS` | `7000` | Лимит prompt-пакета фактов |
 | `PODCAST_LLM_MAX_NEW_TOKENS` | `420` | Лимит ответа LLM |
+| `PODCAST_LLM_ENABLED` | `false` | Включить LLM-сценарист; для `CPU Basic` рекомендуется оставить `false` |
 | `TTS_ENGINE` | `piper` | Сейчас поддерживается `piper` |
-| `TTS_MAX_TEXT_CHARS` | `420` | Лимит одной TTS-реплики |
+| `TTS_MAX_REQUEST_CHARS` | `1800` | Максимальная длина полного текста одного TTS-запроса; при превышении возвращается ошибка |
+| `TTS_CHUNK_MAX_CHARS` | `420` | Внутренний размер фрагмента Piper; полный аудиоответ склеивается из всех фрагментов |
+| `TTS_RUSSIAN_NORMALIZATION_ENABLED` | `true` | Раскрывать русские адресные сокращения и единицы перед синтезом |
 | `PIPER_VOICE_REPO` | `rhasspy/piper-voices` | Репозиторий голосов Piper |
-| `PIPER_VOICE_BASE` | `ru/ru_RU/dmitri/medium` | Папка голоса в репозитории |
-| `PIPER_VOICE_NAME` | `ru_RU-dmitri-medium` | Имя `.onnx` и `.onnx.json` файлов |
+| `PIPER_DEFAULT_VOICE` | `ru_RU-irina-medium` | Основной голос из разрешённого списка |
 
 ## API
 
@@ -82,6 +87,8 @@ Content-Type: application/json
 }
 ```
 
+На бесплатном `CPU Basic` ответ по умолчанию содержит `provider: template-fallback` и формируется без загрузки Qwen. После перевода Space на более мощный hardware можно установить переменную окружения `PODCAST_LLM_ENABLED=true` и сравнить время ответа.
+
 ```http
 POST /tts
 Content-Type: application/json
@@ -89,12 +96,13 @@ Content-Type: application/json
 {
   "text": "Короткий текст на русском",
   "role": "guide",
+  "voice": "ru_RU-irina-medium",
   "speed": 1,
   "format": "wav"
 }
 ```
 
-Ответ: `audio/wav` или `audio/ogg`.
+Ответ: `audio/wav` или `audio/ogg`; заголовок `X-TTS-Voice` сообщает фактически выбранный голос. Допустимые значения `voice`: `ru_RU-irina-medium`, `ru_RU-dmitri-medium`. Например, текст `г. Иваново, ул. Ленина, д. 4, 3 км` в серверной озвучке произносится в раскрытом русском виде, но исходная строка в UI не меняется.
 
 ## Локальная проверка
 
@@ -117,5 +125,8 @@ curl -X POST http://127.0.0.1:7860/podcast-script ^
 curl -X POST http://127.0.0.1:7860/tts ^
   -H "Content-Type: application/json" ^
   -o sample.wav ^
-  -d "{\"text\":\"Привет! Это тест аудиогида.\",\"role\":\"guide\",\"format\":\"wav\"}"
+  -d "{\"text\":\"Привет! Это тест аудиогида.\",\"role\":\"guide\",\"voice\":\"ru_RU-irina-medium\",\"format\":\"wav\"}"
 ```
+
+Для проверки выбранного голоса используйте ответ с заголовками и убедитесь, что сервис возвращает
+`X-TTS-Voice: ru_RU-irina-medium`.

app.py

@@ -32,7 +32,9 @@ LLM_MAX_NEW_TOKENS = int(os.getenv('PODCAST_LLM_MAX_NEW_TOKENS', '420'))
 PODCAST_LLM_ENABLED = os.getenv('PODCAST_LLM_ENABLED', 'false').lower() in {'1', 'true', 'yes', 'on'}
 
 TTS_ENGINE = os.getenv('TTS_ENGINE', 'piper').lower()
-TTS_MAX_TEXT_CHARS = int(os.getenv('TTS_MAX_TEXT_CHARS', '420'))
+TTS_MAX_REQUEST_CHARS = int(os.getenv('TTS_MAX_REQUEST_CHARS', os.getenv('TTS_MAX_TEXT_CHARS', '1800')))
+TTS_CHUNK_MAX_CHARS = int(os.getenv('TTS_CHUNK_MAX_CHARS', '420'))
+TTS_RUSSIAN_NORMALIZATION_ENABLED = os.getenv('TTS_RUSSIAN_NORMALIZATION_ENABLED', 'true').lower() in {'1', 'true', 'yes', 'on'}
 PIPER_VOICE_REPO = os.getenv('PIPER_VOICE_REPO', 'rhasspy/piper-voices')
 PIPER_DEFAULT_VOICE = os.getenv('PIPER_DEFAULT_VOICE', 'ru_RU-irina-medium')
 PIPER_FALLBACK_VOICE = 'ru_RU-dmitri-medium'
@@ -128,12 +130,131 @@ def clean_text(value: str | None, limit: int = 900) -> str:
     return shortened.rsplit(' ', 1)[0].strip()
 
 
+def clean_full_text(value: str | None) -> str:
+    if not value:
+        return ''
+
+    text = re.sub(r'[\x00-\x1f]+', ' ', str(value))
+    return re.sub(r'\s+', ' ', text).strip()
+
+
+def russian_number_unit(raw_number: str, forms: tuple[str, str, str]) -> str:
+    spoken_number = raw_number.replace('.', ',')
+    if ',' in spoken_number:
+        return f'{spoken_number} {forms[1]}'
+
+    value = int(spoken_number)
+    remainder_100 = value % 100
+    remainder_10 = value % 10
+    if 11 <= remainder_100 <= 14:
+        form = forms[2]
+    elif remainder_10 == 1:
+        form = forms[0]
+    elif 2 <= remainder_10 <= 4:
+        form = forms[1]
+    else:
+        form = forms[2]
+    return f'{spoken_number} {form}'
+
+
+def normalize_spoken_russian(text: str) -> str:
+    if not TTS_RUSSIAN_NORMALIZATION_ENABLED:
+        return text
+
+    normalized = text
+    address_rules = [
+        (r'\bв\s+г\.\s*(?=[А-ЯЁ])', 'в городе '),
+        (r'\bиз\s+г\.\s*(?=[А-ЯЁ])', 'из города '),
+        (r'\bпо\s+г\.\s*(?=[А-ЯЁ])', 'по городу '),
+        (r'\bг\.\s*(?=[А-ЯЁ])', 'город '),
+        (r'\bна\s+ул\.\s*', 'на улице '),
+        (r'\bпо\s+ул\.\s*', 'по улице '),
+        (r'\bс\s+ул\.\s*', 'с улицы '),
+        (r'\bул\.\s*', 'улица '),
+        (r'\bна\s+(?:пр-т|просп\.)\s*', 'на проспекте '),
+        (r'\bпо\s+(?:пр-т|просп\.)\s*', 'по проспекту '),
+        (r'\b(?:пр-т|просп\.)\s*', 'проспект '),
+        (r'\bв\s+пер\.\s*', 'в переулке '),
+        (r'\bпо\s+пер\.\s*', 'по переулку '),
+        (r'\bпер\.\s*', 'переулок '),
+        (r'\bна\s+пл\.\s*', 'на площади '),
+        (r'\bпл\.\s*', 'площадь '),
+        (r'\bд\.\s*(?=\d)', 'дом '),
+        (r'\bкорп\.\s*(?=\d)', 'корпус '),
+        (r'\bстр\.\s*(?=\d)', 'строение '),
+    ]
+    normalized = re.sub(r'\bв\s+(\d{3,4})\s*г\.\s*', r'в \1 году ', normalized)
+    normalized = re.sub(r'\b(\d{3,4})\s*г\.\s*', r'\1 год ', normalized)
+    for pattern, replacement in address_rules:
+        normalized = re.sub(pattern, replacement, normalized, flags=re.IGNORECASE)
+
+    unit_rules = [
+        (r'(\d+(?:[.,]\d+)?)\s*км\s*/\s*ч\b', ('километр в час', 'километра в час', 'километров в час')),
+        (r'(\d+(?:[.,]\d+)?)\s*км\b', ('километр', 'километра', 'километров')),
+        (r'(\d+(?:[.,]\d+)?)\s*мин\b', ('минута', 'минуты', 'минут')),
+        (r'(\d+(?:[.,]\d+)?)\s*ч\b', ('час', 'часа', 'часов')),
+        (r'(\d+(?:[.,]\d+)?)\s*м\b', ('метр', 'метра', 'метров')),
+    ]
+    for pattern, forms in unit_rules:
+        normalized = re.sub(pattern, lambda match: russian_number_unit(match.group(1), forms), normalized)
+    return re.sub(r'\s+', ' ', normalized).strip()
+
+
 def normalize_tts_text(text: str) -> str:
-    normalized = clean_text(text, TTS_MAX_TEXT_CHARS)
+    normalized = clean_full_text(text)
     if not normalized:
         raise HTTPException(status_code=400, detail='Text is required.')
 
-    return normalized
+    if len(normalized) > TTS_MAX_REQUEST_CHARS:
+        raise HTTPException(status_code=400, detail='TTS text exceeds maximum request length.')
+
+    return normalize_spoken_russian(normalized)
+
+
+def split_tts_chunks(text: str, max_chars: int = TTS_CHUNK_MAX_CHARS) -> list[str]:
+    if max_chars < 20:
+        raise ValueError('TTS chunk size must be at least 20 characters.')
+
+    chunks: list[str] = []
+    current = ''
+    phrases = re.findall(r'.+?(?:[.!?;:]+(?=\s|$)|$)', text)
+    for phrase in phrases:
+        phrase = phrase.strip()
+        if not phrase:
+            continue
+        if len(phrase) > max_chars:
+            words = phrase.split()
+            pieces: list[str] = []
+            part = ''
+            for word in words:
+                if len(word) > max_chars:
+                    if part:
+                        pieces.append(part)
+                        part = ''
+                    # An unusually long token is preserved rather than read as broken fragments.
+                    pieces.append(word)
+                elif not part or len(part) + len(word) + 1 <= max_chars:
+                    part = f'{part} {word}'.strip()
+                else:
+                    pieces.append(part)
+                    part = word
+            if part:
+                pieces.append(part)
+        else:
+            pieces = [phrase]
+
+        for piece in pieces:
+            if not current:
+                current = piece
+            elif len(current) + len(piece) + 1 <= max_chars:
+                current = f'{current} {piece}'
+            else:
+                chunks.append(current)
+                current = piece
+
+    if current:
+        chunks.append(current)
+    return chunks or [text]
 
 
 def resolve_piper_voice(voice: str, role: str) -> str:
@@ -536,7 +657,7 @@ def piper_paths(voice_name: str) -> tuple[str, str]:
     return model_path, config_path
 
 
-def synthesize_with_piper(text: str, speed: float, voice_name: str) -> tuple[np.ndarray, int]:
+def synthesize_piper_chunk(text: str, speed: float, voice_name: str) -> tuple[np.ndarray, int]:
     model_path, config_path = piper_paths(voice_name)
     with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as wav_file:
         wav_path = wav_file.name
@@ -595,6 +716,25 @@ def synthesize_with_piper(text: str, speed: float, voice_name: str) -> tuple[np.
             pass
 
 
+def synthesize_with_piper(text: str, speed: float, voice_name: str) -> tuple[np.ndarray, int]:
+    chunks = split_tts_chunks(text, TTS_CHUNK_MAX_CHARS)
+    rendered_chunks: list[np.ndarray] = []
+    sample_rate = DEFAULT_SAMPLE_RATE
+
+    for index, chunk in enumerate(chunks):
+        chunk_audio, chunk_sample_rate = synthesize_piper_chunk(chunk, speed, voice_name)
+        if index == 0:
+            sample_rate = chunk_sample_rate
+        elif chunk_sample_rate != sample_rate:
+            raise HTTPException(status_code=502, detail='Piper returned mismatched audio sample rates.')
+
+        rendered_chunks.append(np.asarray(chunk_audio, dtype='float32'))
+        if index < len(chunks) - 1:
+            rendered_chunks.append(np.zeros(max(1, int(sample_rate * 0.06)), dtype='float32'))
+
+    return np.concatenate(rendered_chunks), sample_rate
+
+
 def write_audio(audio: np.ndarray, sample_rate: int, requested_format: str) -> tuple[bytes, str]:
     buffer = io.BytesIO()
     requested_format = requested_format.lower()
@@ -627,6 +767,7 @@ def health():
         'podcast_llm_enabled': PODCAST_LLM_ENABLED,
         'tts_engine': TTS_ENGINE,
         'tts_voice': PIPER_DEFAULT_VOICE if TTS_ENGINE == 'piper' else 'disabled',
+        'tts_russian_normalization_enabled': TTS_RUSSIAN_NORMALIZATION_ENABLED,
     }
 
 
@@ -648,7 +789,9 @@ def diagnostics():
         'last_script_error': LAST_SCRIPT_ERROR,
         'last_script_error_type': LAST_SCRIPT_ERROR_TYPE,
         'tts_engine': TTS_ENGINE,
-        'tts_max_text_chars': TTS_MAX_TEXT_CHARS,
+        'tts_max_request_chars': TTS_MAX_REQUEST_CHARS,
+        'tts_chunk_max_chars': TTS_CHUNK_MAX_CHARS,
+        'tts_russian_normalization_enabled': TTS_RUSSIAN_NORMALIZATION_ENABLED,
         'piper_voice_repo': PIPER_VOICE_REPO,
         'piper_default_voice': PIPER_DEFAULT_VOICE,
         'piper_allowed_voices': list(PIPER_VOICES.keys()),

test_app.py

@@ -0,0 +1,60 @@
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+from fastapi import HTTPException
+
+import app
+
+
+class SpokenRussianTests(unittest.TestCase):
+    def test_address_forms_are_expanded_for_speech(self):
+        text = 'В г. Иваново, на ул. Ленина, д. 4 и корп. 2.'
+
+        self.assertEqual(
+            app.normalize_spoken_russian(text),
+            'В городе Иваново, на улице Ленина, дом 4 и корпус 2.',
+        )
+
+    def test_route_units_are_expanded(self):
+        text = 'Маршрут: 3 км, 250 м, 21 мин, скорость 12 км/ч.'
+
+        self.assertEqual(
+            app.normalize_spoken_russian(text),
+            'Маршрут: 3 километра, 250 метров, 21 минута, скорость 12 километров в час.',
+        )
+
+    def test_request_over_limit_fails_instead_of_truncating(self):
+        with self.assertRaises(HTTPException):
+            app.normalize_tts_text('а' * (app.TTS_MAX_REQUEST_CHARS + 1))
+
+
+class PiperChunkTests(unittest.TestCase):
+    def test_long_text_keeps_tail_in_last_chunk(self):
+        text = 'Первая фраза достаточно длинная. Финальная фраза должна прозвучать полностью.'
+        chunks = app.split_tts_chunks(text, 35)
+
+        self.assertGreater(len(chunks), 1)
+        self.assertIn('полностью.', chunks[-1])
+        self.assertEqual(' '.join(chunks), text)
+
+    def test_multiple_chunks_are_returned_as_one_audio_array(self):
+        with patch.object(app, 'TTS_CHUNK_MAX_CHARS', 30), patch.object(
+            app,
+            'synthesize_piper_chunk',
+            side_effect=[(np.array([0.1, 0.2], dtype='float32'), 100), (np.array([0.3], dtype='float32'), 100)],
+        ) as synthesizer:
+            audio, sample_rate = app.synthesize_with_piper(
+                'Первая длинная реплика. Вторая длинная реплика.',
+                1.0,
+                'ru_RU-irina-medium',
+            )
+
+        self.assertEqual(synthesizer.call_count, 2)
+        self.assertEqual(sample_rate, 100)
+        self.assertGreater(len(audio), 3)
+        self.assertAlmostEqual(float(audio[-1]), 0.3, places=6)
+
+
+if __name__ == '__main__':
+    unittest.main()