Upload 12 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+demo1_conversation.wav filter=lfs diff=lfs merge=lfs -text
+demo2_numbers.wav filter=lfs diff=lfs merge=lfs -text
+demo3_expressive.wav filter=lfs diff=lfs merge=lfs -text

Ani-Voice-API.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf77670c80c71675c2bdfe9404fbe7ddcd045ea3ec7f72bd34751a9a584fa033
+size 140639241

README.md

@@ -1,14 +1,66 @@
 ---
-title: Ani Voice API
-emoji: 😻
-colorFrom: pink
-colorTo: green
-sdk: gradio
-sdk_version: 6.17.3
-python_version: '3.13'
-app_file: app.py
-pinned: false
+language:
+  - bg
 license: mit
+tags:
+  - text-to-speech
+  - tts
+  - bulgarian
+  - fastapi
+pipeline_tag: text-to-speech
 ---
+# Ani Voice API
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Завършен TTS (Text-to-Speech) пакет за български език, базиран на BgTTS и Supertonic, обвит в гъвкаво FastAPI приложение.
+
+*Проектът е създаден и разработен от **Ani-Antigravity** по идея и желание на **Наско (@beleata74)**.*
+
+## Инсталация
+
+1. Уверете се, че имате Python 3.10+
+2. Инсталирайте нужните зависимости:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Стартиране на API сървъра
+
+```bash
+python api.py
+```
+Сървърът ще тръгне на `http://localhost:8000`. Можете да разгледате автоматичната документация на `http://localhost:8000/docs`.
+
+## Използване
+
+### 1. Генериране на цял аудио файл
+Изпраща текст и връща завършен `.wav` файл.
+
+**Пример:**
+```bash
+curl -X POST "http://localhost:8000/api/v1/synthesize" \
+     -H "Content-Type: application/json" \
+     -d '{"text": "Здравей, свят!", "voice_style": "F5", "speed": 1.6}' \
+     --output response.wav
+```
+
+### 2. Стрийминг на аудио (NDJSON)
+Изпраща аудиото на малки парчета (chunks), докато се генерират, кодирани в base64. Полезно за дълги текстове, където искате да пускате аудиото веднага.
+
+Връща редове във формат:
+```json
+{"chunk_index": 0, "audio_base64": "UklGRiQAAABXQVZFZm10IBAAAAABAAEAQB8AAEA..."}
+```
+
+Вижте файла `client_example.py` за пример как да интегрирате API-то в Python код.
+Вижте файла `voice_pipeline.py` за пример на работещ клиент-демон (daemon), който комуникира с API-то и пуска звука в реално време!
+
+## Аудио Демонстрации
+
+В репозиторито можете да намерите няколко предварително генерирани аудио файла, за да чуете как звучи моделът:
+
+1. **`demo1_conversation.wav`**
+   - *Транскрипция:* "Здравейте! Това е тестов запис от нашия нов български TTS модел. Надявам се да ви хареса как звучи гласът ми!"
+2. **`demo2_numbers.wav`** (Демонстрира нормализацията на числа и дати)
+   - *Транскрипция:* "Днес е 15 май 2026 година. Температурата навън е 23.5 градуса, а вятърът духа със скорост 5.4 километра в час. Цената е 1500 лв. за м²."
+3. **`demo3_expressive.wav`**
+   - *Транскрипция:* "Супер! Наистина много се радвам, че всичко най-накрая работи гладко. Усилията определено си заслужаваха!"

api.py

@@ -0,0 +1,53 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+import uvicorn
+
+# Импортираме tts_engine - това автоматично ще зареди моделите в паметта при стартиране!
+from tts_engine import engine
+
+app = FastAPI(title="Ani Voice API", version="1.0.0")
+
+class SynthesizeRequest(BaseModel):
+    text: str
+    voice_style: str = "F5"
+    speed: float = 1.6
+
+@app.post("/api/v1/synthesize")
+def synthesize_full_audio(request: SynthesizeRequest):
+    """
+    Генерира аудио за целия текст и го връща като един WAV файл.
+    Подходящо за кратки съобщения.
+    """
+    try:
+        audio_bytes = engine.synthesize_full(request.text, request.voice_style, request.speed)
+        if not audio_bytes:
+            raise HTTPException(status_code=400, detail="Неуспешно генериране на аудио (празен текст?).")
+            
+        return Response(content=audio_bytes, media_type="audio/wav")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+import base64
+import json
+
+@app.post("/api/v1/synthesize/stream")
+def synthesize_stream_audio(request: SynthesizeRequest):
+    """
+    Стрийминг endpoint, който връща аудио на парчета (chunks).
+    Всеки ред е JSON обект: {"chunk_index": i, "audio_base64": "..."}
+    """
+    def generate():
+        try:
+            for i, audio_bytes in enumerate(engine.synthesize_stream(request.text, request.voice_style, request.speed)):
+                encoded = base64.b64encode(audio_bytes).decode("utf-8")
+                yield json.dumps({"chunk_index": i, "audio_base64": encoded}) + "\n"
+        except Exception as e:
+            print(f"Грешка по време на стрийминг: {e}")
+            yield json.dumps({"error": str(e)}) + "\n"
+            
+    return StreamingResponse(generate(), media_type="application/x-ndjson")
+
+if __name__ == "__main__":
+    print("Стартиране на Ani Voice API сървър на порт 8000...")
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=False)

client_example.py

@@ -0,0 +1,27 @@
+import requests
+
+API_URL = "http://localhost:8000/api/v1/synthesize"
+
+def synthesize_text(text: str, output_file: str):
+    """
+    Изпраща текст към API-то и запазва резултата като WAV файл.
+    """
+    print(f"Изпращане на заявка за: '{text}'...")
+    
+    response = requests.post(API_URL, json={
+        "text": text,
+        "voice_style": "F5",
+        "speed": 1.6
+    })
+    
+    if response.status_code == 200:
+        with open(output_file, "wb") as f:
+            f.write(response.content)
+        print(f"✅ Аудиото е запазено успешно в: {output_file}")
+    else:
+        print(f"❌ Грешка: {response.status_code} - {response.text}")
+
+if __name__ == "__main__":
+    text_to_say = "Здравей! Това е тестов запис, създаден чрез новото Ani Voice API."
+    output_filename = "test_api_output.wav"
+    synthesize_text(text_to_say, output_filename)

demo1_conversation.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5395b9f0d2f01685b82c1592dd236999deec3de7e2a4e1a3ab25611a8f1d01d6
+size 332204

demo2_numbers.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7cdfc164606f698053e9264117e15093f4d15d0d2d7621eee131d03141a4130
+size 762284

demo3_expressive.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed299d60ff6f02ed78d7bce2322fb949e74daf0fbecfb3eae8775425943a36d7
+size 318764

gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+demo1_conversation.wav filter=lfs diff=lfs merge=lfs -text
+demo2_numbers.wav filter=lfs diff=lfs merge=lfs -text
+demo3_expressive.wav filter=lfs diff=lfs merge=lfs -text

normalizer.py

@@ -0,0 +1,41 @@
+import re
+from bg_text_normalizer import normalize_text as bg_norm
+
+# Допълнителни специфични замени, които bg_text_normalizer изпуска
+EXTRA_ABBREVIATIONS = {
+    r"\bм²\b": "квадратен метър",
+    r"\bкв\.м\.\b": "квадратен метър",
+    r"\bт\.е\.\b": "тоест",
+}
+
+def normalize_text(text: str) -> str:
+    """
+    Нормализира текста, използвайки bg-text-normalizer + наши специфични правила.
+    """
+    # 0.5 Предварителна обработка на десетични дроби: заменяме точката със запетая
+    # bg-text-normalizer бърка '1.4' с '1 април'. За да го чете като дроб, му трябва запетая '1,4'.
+    text = re.sub(r'(\d)\.(\d)', r'\1,\2', text)
+    
+    # 1. Първо прилагаме библиотеката bg_text_normalizer
+    text = bg_norm(text)
+    
+    # 2. Оправяме точките след съкращения като "лв." и "гр.", които библиотеката е превърнала в "лева."
+    text = text.replace("лева.", "лева")
+    text = text.replace("стотинки.", "стотинки")
+    
+    # 3. Прилагаме нашите допълнителни правила
+    for pattern, replacement in EXTRA_ABBREVIATIONS.items():
+        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+        
+    # Допълнително хващаме м² (без \b, защото ² не е дума)
+    text = text.replace("м²", "квадратен метър")
+    
+    # Махане на двойни интервали
+    text = re.sub(r"\s+", " ", text).strip()
+    
+    return text
+
+if __name__ == "__main__":
+    test_text = "Цената е 1500 лв. за м² в кв. Лозенец."
+    print("Original:", test_text)
+    print("Normalized:", normalize_text(test_text))

requirements.txt

@@ -0,0 +1,11 @@
+torch==2.13.0.dev20260603+cu132
+torchaudio==2.11.0.dev20260608+cu132
+torchvision==0.28.0.dev20260608+cu132
+numpy<2.0.0
+supertonic==1.3.1
+bg-text-normalizer==1.1.0
+num2cyrillic==1.0.0
+fastapi>=0.110.0
+uvicorn>=0.29.0
+pydantic>=2.7.0
+requests>=2.31.0

tts_engine.py

@@ -0,0 +1,157 @@
+import os
+import io
+import re
+import wave
+import torch
+import numpy as np
+import tempfile
+import sys
+import supertonic
+
+# Добавяме BgTTS към sys.path, за да може вътрешните му импорти да работят
+sys.path.append(os.path.join(os.path.dirname(__file__), 'BgTTS'))
+from inference import synthesize
+from normalizer import normalize_text
+
+class TTSEngine:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Зареждам TTS Engine на устройство: {self.device}")
+        
+        # Supertonic (Референтно аудио)
+        from supertonic import TTS
+        self.engine = TTS(auto_download=True)
+        
+        # BgTTS (Основен модел)
+        self.bgtts_checkpoint = os.path.join(os.path.dirname(__file__), "BgTTS", "checkpoint_inference.pt")
+        # BgTTS inference.synthesize зарежда модела всеки път, ако не му подадем модела. 
+        # В текущия BgTTS/inference.py synthesize() вика load_for_inference(), ако се подаде път.
+        # За сега ще ползваме пътя, тъй като така е написан BgTTS. 
+        # Ако искаме пълно кеширане, може да се наложи леко пренаписване на BgTTS/inference.py.
+        # Но засега ще ползваме оригиналната synthesize функция.
+        
+        print("TTS Engine зареден успешно.")
+
+    def split_text_for_tts(self, text: str) -> list[str]:
+        text = text.strip()
+        if not text:
+            return []
+        raw = re.split(r'(?<=[\.\!\?…])\s+|\n+', text)
+        chunks = []
+        buf = ""
+        for part in raw:
+            part = part.strip()
+            if not part: continue
+            
+            if not buf or len(buf) < 80 or len(buf) + len(part) + 1 <= 200:
+                buf = (buf + " " + part).strip()
+            else:
+                chunks.append(buf)
+                buf = part
+        if buf: chunks.append(buf)
+        return chunks
+
+    def generate_chunk(self, chunk_text: str, voice_style: str = "F5", speed: float = 1.6) -> bytes:
+        """
+        Генерира аудио за едно изречение (chunk) и го връща като WAV байтове.
+        """
+        clean_text = chunk_text.replace('"', '').replace('„', '').replace('“', '') \
+                               .replace("’", "'").replace("–", "-").replace("—", "-") \
+                               .replace("*", "")
+                               
+        if not clean_text.strip():
+            return b""
+            
+        # 1. Генериране на референтно аудио
+        # Ако voice_style е стринг (напр. "F5"), взимаме съответния обект
+        if isinstance(voice_style, str):
+            v_style = self.engine.get_voice_style(voice_name=voice_style)
+        else:
+            v_style = voice_style
+            
+        wav_array, _ = self.engine.synthesize(clean_text, voice_style=v_style, lang="bg", speed=speed)
+        wav_data = np.asarray(wav_array).flatten()
+        wav_max = np.max(np.abs(wav_data))
+        if wav_max > 0:
+            wav_data = wav_data / wav_max
+        pcm_data = (wav_data * 32767).astype(np.int16)
+        
+        # Записваме временно референтното аудио (тъй като BgTTS изисква файл)
+        fd, ref_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        with wave.open(ref_path, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(2)
+            wf.setframerate(44100)
+            wf.writeframes(pcm_data.tobytes())
+            
+        # 2. Генериране на крайното аудио
+        fd, final_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        
+        try:
+            synthesize(checkpoint=self.bgtts_checkpoint, 
+                       text=clean_text, 
+                       output=final_path, 
+                       speaker_wav=ref_path,
+                       device=self.device)
+                       
+            # Прочитане на резултата
+            with open(final_path, "rb") as f:
+                audio_bytes = f.read()
+                
+            return audio_bytes
+            
+        finally:
+            try:
+                os.remove(ref_path)
+                os.remove(final_path)
+            except OSError:
+                pass
+
+    def synthesize_stream(self, text: str, voice_style: str = "F5", speed: float = 1.6):
+        """
+        Генератор, който нормализира текста, цепи го на парчета и връща WAV байтове за всяко парче.
+        """
+        normalized_text = normalize_text(text)
+        chunks = self.split_text_for_tts(normalized_text)
+        
+        for chunk in chunks:
+            audio_bytes = self.generate_chunk(chunk, voice_style, speed)
+            if audio_bytes:
+                yield audio_bytes
+
+    def synthesize_full(self, text: str, voice_style: str = "F5", speed: float = 1.6) -> bytes:
+        """
+        Нормализира текста, цепи го, генерира всички парчета и ги слепва в един общ WAV файл.
+        """
+        normalized_text = normalize_text(text)
+        chunks = self.split_text_for_tts(normalized_text)
+        
+        all_frames = b""
+        params = None
+        
+        for chunk in chunks:
+            audio_bytes = self.generate_chunk(chunk, voice_style, speed)
+            if not audio_bytes:
+                continue
+                
+            # Парсване на WAV данните, за да можем да ги слеем без да дублираме хедъри
+            with wave.open(io.BytesIO(audio_bytes), "rb") as wf:
+                if not params:
+                    params = wf.getparams()
+                all_frames += wf.readframes(wf.getnframes())
+                
+        if not params:
+            return b""
+            
+        # Създаване на крайния WAV
+        out_io = io.BytesIO()
+        with wave.open(out_io, "wb") as wf:
+            wf.setparams(params)
+            wf.writeframes(all_frames)
+            
+        return out_io.getvalue()
+
+# Глобална инстанция за по-лесно преизползване
+engine = TTSEngine()

voice_pipeline.py

@@ -0,0 +1,108 @@
+import os
+import time
+import json
+import base64
+import requests
+import tempfile
+import threading
+import queue
+import winsound
+
+TRANSCRIPT_PATH = r"C:\Users\nasko\.gemini\antigravity\brain\695897cf-1c58-4886-a686-e9d8c406ebef\.system_generated\logs\transcript.jsonl"
+API_URL = "http://localhost:8000/api/v1/synthesize/stream"
+
+audio_queue = queue.Queue()
+
+def player_worker():
+    """
+    Взима готови WAV файлове от опашката и ги пуска.
+    """
+    while True:
+        file_path = audio_queue.get()
+        if file_path is None: break
+        
+        print(f"🔊 Възпроизвеждам от API...")
+        winsound.PlaySound(file_path, winsound.SND_FILENAME)
+        
+        try:
+            os.remove(file_path)
+        except OSError:
+            pass
+            
+        audio_queue.task_done()
+
+def process_text(text: str):
+    """
+    Изпраща текста към API-то и чака за стрийминг на аудио парчета.
+    """
+    print(f"📡 Изпращане към API: {text[:50]}...")
+    try:
+        response = requests.post(API_URL, json={
+            "text": text,
+            "voice_style": "F5",
+            "speed": 1.6
+        }, stream=True)
+        
+        if response.status_code != 200:
+            print(f"Грешка от API: {response.status_code} - {response.text}")
+            return
+            
+        for line in response.iter_lines():
+            if line:
+                data = json.loads(line)
+                if "error" in data:
+                    print(f"API Грешка: {data['error']}")
+                    continue
+                    
+                chunk_index = data.get("chunk_index")
+                audio_base64 = data.get("audio_base64")
+                
+                if audio_base64:
+                    audio_bytes = base64.b64decode(audio_base64)
+                    
+                    # Записваме временно файла и го пускаме в опашката
+                    fd, file_path = tempfile.mkstemp(suffix=f"_chunk_{chunk_index}.wav")
+                    os.close(fd)
+                    
+                    with open(file_path, "wb") as f:
+                        f.write(audio_bytes)
+                        
+                    audio_queue.put(file_path)
+    except requests.exceptions.ConnectionError:
+        print("Не мога да се свържа с API-то! Увери се, че `api.py` работи на порт 8000.")
+    except Exception as e:
+        print(f"Грешка при комуникация с API: {e}")
+
+def tail_file():
+    """
+    Следи чата (transcript.jsonl) за нови съобщения от модела.
+    """
+    if not os.path.exists(TRANSCRIPT_PATH):
+        print(f"Файлът не съществува: {TRANSCRIPT_PATH}")
+        return
+        
+    with open(TRANSCRIPT_PATH, "r", encoding="utf-8") as f:
+        f.seek(0, 2) 
+        
+        while True:
+            line = f.readline()
+            if not line:
+                time.sleep(0.5)
+                continue
+            
+            try:
+                data = json.loads(line)
+                if data.get("source") == "MODEL" and data.get("type") in ["PLANNER_RESPONSE", "GENERIC"]:
+                    full_text = data.get("content", "")
+                    if full_text and not full_text.startswith("Created At:"):
+                        print("\n📝 Получен нов текст от чата.")
+                        process_text(full_text)
+            except Exception as e:
+                pass
+
+if __name__ == "__main__":
+    t_play = threading.Thread(target=player_worker, daemon=True)
+    t_play.start()
+    
+    print("Ani Voice Client слуша за съобщения и чака API-то...")
+    tail_file()