Upload 5 files

DEPLOYMENT.md

@@ -0,0 +1,179 @@
+# 🚀 Hugging Face Space 部署指南
+
+本指南将帮助你将 Genie-TTS OpenAI 兼容 API 部署到 Hugging Face Space。
+
+## 📋 前置要求
+
+1. Hugging Face 账号
+2. 模型文件的下载链接（.pth 和 .ckpt）
+3. 参考音频文件
+
+## 🔧 部署步骤
+
+### 步骤 1: 创建 Hugging Face Space
+
+1. 访问 [Hugging Face Spaces](https://huggingface.co/spaces)
+2. 点击 "Create new Space"
+3. 填写信息：
+   - **Space name**: 选择一个名称，如 `genie-tts-api`
+   - **License**: MIT
+   - **SDK**: Docker
+   - **Hardware**: CPU Basic（免费）或更高配置
+4. 点击 "Create Space"
+
+### 步骤 2: 上传文件
+
+将以下文件上传到你的 Space 仓库：
+
+```
+├── Dockerfile
+├── app.py
+├── requirements.txt
+├── README.md
+└── models/
+    └── liang/
+        └── config.json
+```
+
+**方法一：使用 Git**
+
+```bash
+# 克隆你的 Space 仓库
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# 复制文件
+cp -r /path/to/huggingface-space/* .
+
+# 提交并推送
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+**方法二：使用 Web 界面**
+
+1. 在 Space 页面点击 "Files" 标签
+2. 点击 "Add file" > "Upload files"
+3. 上传所有必要文件
+
+### 步骤 3: 等待构建
+
+- Space 会自动开始构建 Docker 镜像
+- 构建过程包括：
+  1. 安装依赖
+  2. 下载模型文件
+  3. 转换为 ONNX 格式
+- 这个过程可能需要 10-30 分钟
+
+### 步骤 4: 验证部署
+
+构建完成后：
+
+1. 访问健康检查端点：
+   ```
+   https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health
+   ```
+
+2. 测试 API：
+   ```bash
+   curl -X POST "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/v1/audio/speech" \
+     -H "Content-Type: application/json" \
+     -d '{"model": "liang", "input": "你好，这是测试。"}' \
+     --output test.wav
+   ```
+
+## ⚙️ 自定义配置
+
+### 添加新的语音模型
+
+1. 修改 `Dockerfile`，添加新模型的下载和转换：
+
+```dockerfile
+# 下载新模型
+RUN wget -O /app/temp/new_model.ckpt "YOUR_CKPT_URL" && \
+    wget -O /app/temp/new_model.pth "YOUR_PTH_URL" && \
+    wget -O /app/models/new_voice/reference/audio.wav "YOUR_REF_AUDIO_URL"
+
+# 转换新模型
+RUN python -c "
+import genie_tts as genie
+genie.convert_to_onnx(
+    torch_ckpt_path='/app/temp/new_model.ckpt',
+    torch_pth_path='/app/temp/new_model.pth',
+    output_dir='/app/models/new_voice/onnx'
+)
+"
+```
+
+2. 创建配置文件 `models/new_voice/config.json`：
+
+```json
+{
+    "reference_audio": "reference/audio.wav",
+    "reference_text": "参考音频的文本内容",
+    "language": "Chinese"
+}
+```
+
+### 修改模型下载链接
+
+编辑 `Dockerfile` 中的以下部分：
+
+```dockerfile
+RUN wget -O /app/temp/model.ckpt "YOUR_NEW_CKPT_URL" && \
+    wget -O /app/temp/model.pth "YOUR_NEW_PTH_URL" && \
+    wget -O /app/models/liang/reference/audio.wav "YOUR_NEW_REF_AUDIO_URL"
+```
+
+### 支持的语言
+
+修改 `config.json` 中的 `language` 字段：
+
+- `Chinese` - 中文
+- `English` - 英语
+- `Japanese` - 日语
+- `Korean` - 韩语
+
+## 🐛 故障排除
+
+### 构建失败
+
+1. **检查日志**：在 Space 页面查看构建日志
+2. **模型下载失败**：确保下载链接可访问
+3. **内存不足**：升级到更高配置的硬件
+
+### API 响应慢
+
+- 免费版 CPU 推理较慢，考虑升级硬件
+- 首次请求会加载模型，后续请求会更快
+
+### 模型加载失败
+
+1. 检查 ONNX 转换是否成功
+2. 确保 `config.json` 配置正确
+3. 检查参考音频文件是否存在
+
+## 💡 优化建议
+
+### 减少镜像大小
+
+构建完成后删除 PyTorch：
+
+```dockerfile
+RUN pip uninstall -y torch && rm -rf /root/.cache/pip
+```
+
+### 使用 GPU
+
+1. 在 Space 设置中选择 GPU 硬件
+2. 修改 `requirements.txt` 使用 GPU 版本的依赖
+
+### 私有部署
+
+如果需要私有部署，可以将 Space 设置为私有，并使用 Hugging Face Token 访问。
+
+## 📞 获取帮助
+
+- [Genie-TTS GitHub Issues](https://github.com/High-Logic/Genie-TTS/issues)
+- [Hugging Face Spaces 文档](https://huggingface.co/docs/hub/spaces)

Dockerfile

@@ -0,0 +1,102 @@
+# Genie-TTS OpenAI Compatible API - Docker Image
+# ================================================
+# This Dockerfile builds a container that:
+# 1. Downloads PyTorch model files (.pth, .ckpt) from cloud URLs
+# 2. Converts them to ONNX format
+# 3. Runs the OpenAI-compatible TTS API server
+
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    MODELS_DIR=/app/models \
+    GENIE_DATA_DIR=/app/genie_data
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libsndfile1 \
+    ffmpeg \
+    wget \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies (including torch for model conversion)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install PyTorch (CPU version for model conversion)
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+
+# Install genie-tts from source or pip
+# Option 1: Install from pip
+RUN pip install --no-cache-dir genie-tts
+
+# Create directories
+RUN mkdir -p /app/models/liang/onnx \
+    && mkdir -p /app/models/liang/reference \
+    && mkdir -p /app/genie_data \
+    && mkdir -p /app/temp
+
+# Download model files
+# Model: liang (Chinese V2ProPlus)
+RUN echo "Downloading model files..." && \
+    wget -q --show-progress -O /app/temp/model.ckpt \
+    "https://22333misaka-openlist.hf.space/d/od/shantianliang_proplus_e32.ckpt" && \
+    wget -q --show-progress -O /app/temp/model.pth \
+    "https://22333misaka-openlist.hf.space/d/od/shantianliang_proplus_e8_s192.pth" && \
+    wget -q --show-progress -O /app/models/liang/reference/audio.wav \
+    "https://22333misaka-openlist.hf.space/d/od/ref_shantianliang_1.wav" && \
+    echo "Download complete!"
+
+# Convert PyTorch models to ONNX
+RUN echo "Converting models to ONNX format..." && \
+    python -c "
+import genie_tts as genie
+print('Starting ONNX conversion...')
+genie.convert_to_onnx(
+    torch_ckpt_path='/app/temp/model.ckpt',
+    torch_pth_path='/app/temp/model.pth',
+    output_dir='/app/models/liang/onnx'
+)
+print('ONNX conversion complete!')
+" && \
+    echo "Conversion complete!"
+
+# Clean up temporary files and torch to reduce image size
+RUN rm -rf /app/temp && \
+    pip uninstall -y torch && \
+    rm -rf /root/.cache/pip
+
+# Create model configuration
+RUN echo '{\n\
+    "reference_audio": "reference/audio.wav",\n\
+    "reference_text": "这是一条参考音频，将此音频拖入参考内，再添加文本，即可合成音色",\n\
+    "language": "Chinese"\n\
+}' > /app/models/liang/config.json
+
+# Copy application code
+COPY app.py .
+
+# Download Genie base data
+RUN python -c "import genie_tts; genie_tts.download_genie_data()"
+
+# Expose port (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,158 @@
 ---
-title: Ttsgenie
-emoji: 📚
-colorFrom: indigo
-colorTo: yellow
+title: Genie-TTS OpenAI Compatible API
+emoji: 🔮
+colorFrom: purple
+colorTo: blue
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔮 Genie-TTS OpenAI Compatible API
+
+基于 [Genie-TTS](https://github.com/High-Logic/Genie-TTS) 的 OpenAI 兼容 TTS API 服务。
+
+## 🚀 功能特点
+
+- ✅ **OpenAI API 兼容** - 使用 `/v1/audio/speech` 端点，兼容 OpenAI SDK
+- ✅ **高质量语音合成** - 基于 GPT-SoVITS V2ProPlus 模型
+- ✅ **中文支持** - 目前支持中文语音合成
+- ✅ **WAV 输出** - 32kHz 高质量音频输出
+
+## 📖 API 使用方法
+
+### 端点
+
+```
+POST /v1/audio/speech
+```
+
+### 请求格式
+
+```json
+{
+    "model": "liang",
+    "input": "你好，这是一段测试文本。"
+}
+```
+
+### 请求参数
+
+| 参数 | 类型 | 必需 | 说明 |
+|------|------|------|------|
+| `model` | string | ✅ | 语音模型名称 |
+| `input` | string | ✅ | 要合成的文本 |
+| `voice` | string | ❌ | 忽略 - 仅用于 OpenAI 兼容性 |
+| `response_format` | string | ❌ | 忽略 - 只支持 wav |
+| `speed` | number | ❌ | 忽略 - 仅用于 OpenAI 兼容性 |
+
+### 响应
+
+- Content-Type: `audio/wav`
+- 返回 WAV 格式的音频二进制数据
+
+## 💻 使用示例
+
+### 使用 curl
+
+```bash
+curl -X POST "https://your-space.hf.space/v1/audio/speech" \
+  -H "Content-Type: application/json" \
+  -d '{"model": "liang", "input": "你好，欢迎使用语音合成服务。"}' \
+  --output speech.wav
+```
+
+### 使用 Python requests
+
+```python
+import requests
+
+response = requests.post(
+    "https://your-space.hf.space/v1/audio/speech",
+    json={
+        "model": "liang",
+        "input": "你好，这是一段测试文本。"
+    }
+)
+
+with open("speech.wav", "wb") as f:
+    f.write(response.content)
+```
+
+### 使用 OpenAI Python SDK
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="not-needed",  # API key 不需要
+    base_url="https://your-space.hf.space/v1"
+)
+
+response = client.audio.speech.create(
+    model="liang",
+    input="你好，这是一段测试文本。",
+    voice="alloy"  # 会被忽略
+)
+
+response.stream_to_file("speech.wav")
+```
+
+## 🔧 其他端点
+
+### 健康检查
+
+```
+GET /health
+```
+
+响应:
+```json
+{
+    "status": "healthy",
+    "models_loaded": 1,
+    "available_models": ["liang"]
+}
+```
+
+### 列出可用模型
+
+```
+GET /v1/models
+```
+
+响应:
+```json
+{
+    "object": "list",
+    "data": [
+        {
+            "id": "liang",
+            "object": "model",
+            "created": 1234567890,
+            "owned_by": "genie-tts"
+        }
+    ]
+}
+```
+
+## 📝 可用模型
+
+| 模型名称 | 语言 | 说明 |
+|----------|------|------|
+| `liang` | 中文 | GPT-SoVITS V2ProPlus 模型 |
+
+## ⚠️ 注意事项
+
+1. 首次加载可能需要一些时间
+2. 免费版 CPU 推理可能较慢
+3. 音频输出固定为 WAV 格式 (32kHz, 16-bit, 单声道)
+
+## 🔗 相关链接
+
+- [Genie-TTS GitHub](https://github.com/High-Logic/Genie-TTS)
+- [GPT-SoVITS](https://github.com/RVC-Boss/GPT-SoVITS)
+
+## 📄 许可证
+
+MIT License

app.py

@@ -0,0 +1,376 @@
+"""
+Genie-TTS OpenAI Compatible API Server
+======================================
+
+This server provides an OpenAI-compatible TTS API endpoint (/v1/audio/speech)
+for the Genie-TTS engine.
+
+Usage:
+    POST /v1/audio/speech
+    {
+        "model": "liang",           # Voice model name
+        "input": "要合成的文本",     # Text to synthesize
+        "voice": "alloy",           # Ignored - for OpenAI compatibility
+        "response_format": "wav",   # Only wav is supported
+        "speed": 1.0                # Ignored - for OpenAI compatibility
+    }
+"""
+
+import os
+import sys
+import io
+import wave
+import json
+import logging
+import asyncio
+from pathlib import Path
+from typing import Optional, Dict, Any, Union
+from contextlib import asynccontextmanager
+
+import numpy as np
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import Response, StreamingResponse, JSONResponse
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Model configuration
+MODELS_DIR = Path(os.environ.get("MODELS_DIR", "/app/models"))
+VOICES: Dict[str, Dict[str, Any]] = {}
+
+# Audio settings
+SAMPLE_RATE = 32000
+CHANNELS = 1
+BYTES_PER_SAMPLE = 2
+
+
+class SpeechRequest(BaseModel):
+    """OpenAI-compatible speech request model."""
+    model: str = Field(..., description="The voice model to use")
+    input: str = Field(..., description="The text to synthesize")
+    voice: Optional[str] = Field(default="alloy", description="Ignored - for OpenAI compatibility")
+    response_format: Optional[str] = Field(default="wav", description="Only wav is supported")
+    speed: Optional[float] = Field(default=1.0, description="Ignored - for OpenAI compatibility")
+
+
+class ErrorResponse(BaseModel):
+    """OpenAI-compatible error response."""
+    error: Dict[str, Any]
+
+
+def load_voice_config(voice_dir: Path) -> Optional[Dict[str, Any]]:
+    """Load voice configuration from a directory."""
+    config_path = voice_dir / "config.json"
+    if not config_path.exists():
+        logger.warning(f"Config file not found: {config_path}")
+        return None
+    
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+        
+        # Validate required fields
+        required_fields = ["reference_audio", "reference_text", "language"]
+        for field in required_fields:
+            if field not in config:
+                logger.error(f"Missing required field '{field}' in {config_path}")
+                return None
+        
+        # Check if ONNX models exist
+        onnx_dir = voice_dir / "onnx"
+        if not onnx_dir.exists():
+            logger.error(f"ONNX model directory not found: {onnx_dir}")
+            return None
+        
+        config["onnx_dir"] = str(onnx_dir)
+        config["voice_dir"] = str(voice_dir)
+        
+        return config
+    except Exception as e:
+        logger.error(f"Failed to load config from {config_path}: {e}")
+        return None
+
+
+def discover_voices() -> Dict[str, Dict[str, Any]]:
+    """Discover all available voice models."""
+    voices = {}
+    
+    if not MODELS_DIR.exists():
+        logger.warning(f"Models directory not found: {MODELS_DIR}")
+        return voices
+    
+    for voice_dir in MODELS_DIR.iterdir():
+        if voice_dir.is_dir():
+            voice_name = voice_dir.name
+            config = load_voice_config(voice_dir)
+            if config:
+                voices[voice_name] = config
+                logger.info(f"Loaded voice: {voice_name} (language: {config.get('language', 'unknown')})")
+    
+    return voices
+
+
+def initialize_genie():
+    """Initialize Genie-TTS engine and load all voice models."""
+    global VOICES
+    
+    logger.info("Initializing Genie-TTS engine...")
+    
+    # Import genie_tts
+    try:
+        import genie_tts as genie
+    except ImportError as e:
+        logger.error(f"Failed to import genie_tts: {e}")
+        raise
+    
+    # Download Genie data if needed
+    logger.info("Checking Genie data...")
+    genie.download_genie_data()
+    
+    # Discover and load voices
+    VOICES = discover_voices()
+    
+    if not VOICES:
+        logger.warning("No voice models found!")
+        return
+    
+    # Load each voice model
+    for voice_name, config in VOICES.items():
+        try:
+            logger.info(f"Loading voice model: {voice_name}")
+            genie.load_character(
+                character_name=voice_name,
+                onnx_model_dir=config["onnx_dir"],
+                language=config["language"]
+            )
+            
+            # Set reference audio
+            ref_audio_path = os.path.join(config["voice_dir"], config["reference_audio"])
+            genie.set_reference_audio(
+                character_name=voice_name,
+                audio_path=ref_audio_path,
+                audio_text=config["reference_text"],
+                language=config["language"]
+            )
+            
+            logger.info(f"Voice model loaded successfully: {voice_name}")
+        except Exception as e:
+            logger.error(f"Failed to load voice model {voice_name}: {e}")
+            del VOICES[voice_name]
+    
+    logger.info(f"Genie-TTS initialized with {len(VOICES)} voice(s)")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager."""
+    # Startup
+    initialize_genie()
+    yield
+    # Shutdown
+    logger.info("Shutting down Genie-TTS server...")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="Genie-TTS OpenAI Compatible API",
+    description="OpenAI-compatible Text-to-Speech API powered by Genie-TTS",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+
+@app.get("/")
+async def root():
+    """Root endpoint - health check."""
+    return {
+        "status": "healthy",
+        "service": "Genie-TTS OpenAI Compatible API",
+        "available_models": list(VOICES.keys())
+    }
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "models_loaded": len(VOICES),
+        "available_models": list(VOICES.keys())
+    }
+
+
+@app.get("/v1/models")
+async def list_models():
+    """List available models (OpenAI-compatible)."""
+    import time
+    
+    models = []
+    for voice_name in VOICES.keys():
+        models.append({
+            "id": voice_name,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "genie-tts"
+        })
+    
+    return {
+        "object": "list",
+        "data": models
+    }
+
+
+def generate_wav_header(data_size: int) -> bytes:
+    """Generate WAV file header."""
+    header = io.BytesIO()
+    
+    # RIFF header
+    header.write(b'RIFF')
+    header.write((data_size + 36).to_bytes(4, 'little'))  # File size - 8
+    header.write(b'WAVE')
+    
+    # fmt chunk
+    header.write(b'fmt ')
+    header.write((16).to_bytes(4, 'little'))  # Chunk size
+    header.write((1).to_bytes(2, 'little'))   # Audio format (PCM)
+    header.write((CHANNELS).to_bytes(2, 'little'))  # Number of channels
+    header.write((SAMPLE_RATE).to_bytes(4, 'little'))  # Sample rate
+    header.write((SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE).to_bytes(4, 'little'))  # Byte rate
+    header.write((CHANNELS * BYTES_PER_SAMPLE).to_bytes(2, 'little'))  # Block align
+    header.write((BYTES_PER_SAMPLE * 8).to_bytes(2, 'little'))  # Bits per sample
+    
+    # data chunk
+    header.write(b'data')
+    header.write(data_size.to_bytes(4, 'little'))
+    
+    return header.getvalue()
+
+
+@app.post("/v1/audio/speech")
+async def create_speech(request: SpeechRequest):
+    """
+    Generate speech from text (OpenAI-compatible endpoint).
+    
+    This endpoint is compatible with the OpenAI TTS API format.
+    Only the 'model' and 'input' parameters are used.
+    """
+    import genie_tts as genie
+    
+    # Validate model
+    if request.model not in VOICES:
+        return JSONResponse(
+            status_code=404,
+            content={
+                "error": {
+                    "message": f"Model '{request.model}' not found. Available models: {list(VOICES.keys())}",
+                    "type": "invalid_request_error",
+                    "code": "model_not_found"
+                }
+            }
+        )
+    
+    # Validate input
+    if not request.input or not request.input.strip():
+        return JSONResponse(
+            status_code=400,
+            content={
+                "error": {
+                    "message": "Input text cannot be empty",
+                    "type": "invalid_request_error",
+                    "code": "invalid_input"
+                }
+            }
+        )
+    
+    try:
+        # Collect audio chunks
+        audio_chunks = []
+        
+        async for chunk in genie.tts_async(
+            character_name=request.model,
+            text=request.input.strip(),
+            play=False,
+            split_sentence=True
+        ):
+            audio_chunks.append(chunk)
+        
+        if not audio_chunks:
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {
+                        "message": "Failed to generate audio",
+                        "type": "server_error",
+                        "code": "generation_failed"
+                    }
+                }
+            )
+        
+        # Combine all chunks
+        audio_data = b''.join(audio_chunks)
+        
+        # Generate complete WAV file
+        wav_header = generate_wav_header(len(audio_data))
+        wav_content = wav_header + audio_data
+        
+        return Response(
+            content=wav_content,
+            media_type="audio/wav",
+            headers={
+                "Content-Disposition": "attachment; filename=speech.wav"
+            }
+        )
+    
+    except Exception as e:
+        logger.error(f"TTS generation failed: {e}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": {
+                    "message": f"TTS generation failed: {str(e)}",
+                    "type": "server_error",
+                    "code": "generation_failed"
+                }
+            }
+        )
+
+
+# Error handlers
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "error": {
+                "message": "Not found",
+                "type": "invalid_request_error",
+                "code": "not_found"
+            }
+        }
+    )
+
+
+@app.exception_handler(500)
+async def internal_error_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": {
+                "message": "Internal server error",
+                "type": "server_error",
+                "code": "internal_error"
+            }
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,20 @@
+# Genie-TTS OpenAI Compatible API - Dependencies
+# ================================================
+
+# Web framework
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+
+# Genie-TTS core dependencies
+genie-tts>=2.0.0
+
+# Audio processing
+soundfile>=0.12.0
+numpy>=1.24.0
+
+# Additional utilities
+pydantic>=2.0.0
+python-multipart>=0.0.6
+
+# HTTP client for health checks
+httpx>=0.24.0