openspeechapi 0.1.0__py3-none-any.whl

openspeech/server/routes/stt.py

@@ -0,0 +1,121 @@
+"""STT REST endpoints."""
+from __future__ import annotations
+from fastapi import APIRouter, File, Form, Request, UploadFile, HTTPException
+from openspeech.core.models import AudioData, STTOptions
+from openspeech.dispatch.fanout import FirstCompleted, HighestConfidence, CollectAll
+from openspeech.exceptions import ProviderNotFoundError, FanOutAllFailedError
+from openspeech.utils.audio_converter import AudioConverter
+
+router = APIRouter()
+
+STRATEGY_MAP = {
+    "first_completed": FirstCompleted,
+    "highest_confidence": HighestConfidence,
+    "collect_all": CollectAll,
+}
+
+
+@router.post("/transcribe")
+async def transcribe(
+    request: Request,
+    audio: UploadFile = File(...),
+    provider: str = Form(...),
+    language: str | None = Form(None),
+    prompt: str | None = Form(None),
+    temperature: float | None = Form(None),
+    model: str | None = Form(None),
+    device: str | None = Form(None),
+    beam_size: int | None = Form(None),
+    compute_type: str | None = Form(None),
+    fp16: bool | None = Form(None),
+):
+    dispatcher = request.app.state.dispatcher
+    audio_bytes = await audio.read()
+    detected_fmt = AudioConverter.detect_format(audio_bytes)
+    audio_data = AudioData(data=audio_bytes, sample_rate=16000, channels=1, format=detected_fmt)
+    opts = STTOptions(
+        language=language,
+        prompt=prompt,
+        temperature=temperature,
+        model=model,
+        device=device,
+        beam_size=beam_size,
+        compute_type=compute_type,
+        fp16=fp16,
+    )
+
+    try:
+        result = await dispatcher.stt.transcribe(provider, audio_data, opts)
+    except ProviderNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:  # noqa: BLE001
+        raise HTTPException(status_code=502, detail=f"Provider '{provider}' failed: {e}")
+
+    if result is None:
+        return {"text": "", "filtered": True}
+
+    return {
+        "text": result.text,
+        "language": result.language,
+        "confidence": result.confidence,
+        "words": [
+            {
+                "text": (w.get("text") if isinstance(w, dict) else w.text),
+                "start_ms": (w.get("start_ms") if isinstance(w, dict) else w.start_ms),
+                "end_ms": (w.get("end_ms") if isinstance(w, dict) else w.end_ms),
+                "confidence": (w.get("confidence") if isinstance(w, dict) else w.confidence),
+            }
+            for w in (result.words or [])
+        ],
+        "duration_ms": result.duration_ms,
+        "provider": provider,
+    }
+
+
+@router.post("/transcribe/fanout")
+async def transcribe_fanout(
+    request: Request,
+    audio: UploadFile = File(...),
+    providers: str = Form(...),  # comma-separated
+    strategy: str = Form("first_completed"),
+    language: str | None = Form(None),
+):
+    dispatcher = request.app.state.dispatcher
+    audio_bytes = await audio.read()
+    detected_fmt = AudioConverter.detect_format(audio_bytes)
+    audio_data = AudioData(data=audio_bytes, sample_rate=16000, channels=1, format=detected_fmt)
+    opts = STTOptions(language=language)
+    provider_list = [p.strip() for p in providers.split(",")]
+
+    strategy_cls = STRATEGY_MAP.get(strategy)
+    if strategy_cls is None:
+        raise HTTPException(
+            status_code=422,
+            detail=f"Unknown strategy: {strategy}. Use: {list(STRATEGY_MAP)}",
+        )
+
+    try:
+        result = await dispatcher.stt.fanout(provider_list, audio_data, opts=opts, strategy=strategy_cls())
+    except ProviderNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except FanOutAllFailedError as e:
+        raise HTTPException(status_code=502, detail=f"All providers failed: {list(e.errors.keys())}")
+    except Exception as e:  # noqa: BLE001
+        raise HTTPException(status_code=502, detail=f"Fanout request failed: {e}")
+
+    # CollectAll returns FanOutResult, others return Transcription
+    if hasattr(result, "successes"):
+        return {
+            "strategy": strategy,
+            "successes": {
+                name: {"text": t.text, "confidence": t.confidence, "language": t.language}
+                for name, t in result.successes.items()
+            },
+            "errors": {name: str(e) for name, e in result.errors.items()},
+        }
+    return {
+        "text": result.text,
+        "language": result.language,
+        "confidence": result.confidence,
+        "provider": "fanout",
+    }

openspeech/server/routes/tts.py

@@ -0,0 +1,159 @@
+"""TTS REST endpoints."""
+from __future__ import annotations
+import time
+from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
+from fastapi.responses import Response
+from pydantic import BaseModel
+from openspeech.core.enums import AudioFormat
+from openspeech.core.models import AudioData, TTSOptions
+from openspeech.exceptions import ProviderNotFoundError
+from openspeech.utils.audio_converter import AudioConverter
+
+router = APIRouter()
+
+_MIME_MAP = {
+    "wav": "audio/wav",
+    "mp3": "audio/mpeg",
+    "ogg": "audio/ogg",
+    "flac": "audio/flac",
+    "opus": "audio/opus",
+    "pcm_16k": "audio/pcm",
+    "pcm_44k": "audio/pcm",
+}
+
+_FORMAT_EXT = {
+    "wav": ".wav",
+    "mp3": ".mp3",
+    "ogg": ".ogg",
+    "flac": ".flac",
+    "opus": ".opus",
+    "pcm_16k": ".pcm",
+    "pcm_44k": ".pcm",
+}
+
+
+class SynthesizeRequest(BaseModel):
+    text: str
+    provider: str
+    voice: str | None = None
+    speed: float = 1.0
+    model: str | None = None
+    stream_transport: str | None = None
+
+
+@router.get("/{provider}/voices")
+async def list_voices(request: Request, provider: str):
+    dispatcher = request.app.state.dispatcher
+    try:
+        dispatcher._get_handle(provider)
+    except ProviderNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+    await dispatcher._lifecycle.ensure_ready(provider)
+    instance = dispatcher._lifecycle.get_instance(provider)
+
+    if instance is None or not hasattr(instance, "list_voices"):
+        return {"voices": []}
+
+    voices = await instance.list_voices()
+    return {"voices": voices}
+
+
+@router.post("/synthesize")
+async def synthesize(request: Request, body: SynthesizeRequest):
+    dispatcher = request.app.state.dispatcher
+    opts = TTSOptions(
+        voice=body.voice,
+        speed=body.speed,
+        model=body.model,
+        stream_transport=body.stream_transport,
+    )
+    started = time.perf_counter()
+
+    try:
+        result = await dispatcher.tts.synthesize(body.provider, body.text, opts)
+    except ProviderNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+    if result is None:
+        raise HTTPException(status_code=500, detail="Synthesis returned no result")
+
+    fmt = str(getattr(result, "format", "wav") or "wav")
+    media_type = _MIME_MAP.get(fmt, "audio/wav")
+
+    return Response(
+        content=result.data,
+        media_type=media_type,
+        headers={
+            "X-Provider": body.provider,
+            "X-Audio-Format": fmt,
+            "X-Sample-Rate": str(result.sample_rate),
+            "X-Duration-Ms": str(result.duration_ms or 0),
+            "X-Elapsed-Ms": str(int((time.perf_counter() - started) * 1000)),
+        },
+    )
+
+
+@router.post("/convert")
+async def convert_audio(
+    audio: UploadFile = File(...),
+    source_format: str = Form("mp3"),
+    target_format: str = Form("wav"),
+    sample_rate: int = Form(16000),
+    channels: int = Form(1),
+):
+    """Convert audio between formats. Requires ffmpeg for MP3/OGG/FLAC/OPUS."""
+    # Validate target format
+    try:
+        target = AudioFormat(target_format)
+    except ValueError:
+        raise HTTPException(status_code=400, detail=f"Unsupported target format: {target_format}")
+
+    data = await audio.read()
+    if not data:
+        raise HTTPException(status_code=400, detail="Empty audio data")
+
+    # Detect or use declared source format
+    try:
+        src_fmt = AudioFormat(source_format)
+    except ValueError:
+        src_fmt = AudioConverter.detect_format(data)
+
+    src_audio = AudioData(
+        data=data,
+        sample_rate=sample_rate,
+        channels=channels,
+        format=src_fmt,
+    )
+
+    try:
+        result = AudioConverter.convert(src_audio, target)
+    except RuntimeError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    ext = _FORMAT_EXT.get(target_format, ".bin")
+    media_type = _MIME_MAP.get(target_format, "application/octet-stream")
+
+    return Response(
+        content=result.data,
+        media_type=media_type,
+        headers={
+            "Content-Disposition": f'attachment; filename="audio{ext}"',
+            "X-Audio-Format": target_format,
+            "X-Sample-Rate": str(result.sample_rate),
+        },
+    )
+
+
+@router.get("/formats")
+async def supported_formats():
+    """Return supported download formats and whether ffmpeg is available."""
+    has_ffmpeg = AudioConverter.ffmpeg_available()
+    formats = [
+        {"id": "wav", "label": "WAV", "ext": ".wav", "available": True},
+        {"id": "mp3", "label": "MP3", "ext": ".mp3", "available": has_ffmpeg},
+        {"id": "ogg", "label": "OGG Vorbis", "ext": ".ogg", "available": has_ffmpeg},
+        {"id": "flac", "label": "FLAC", "ext": ".flac", "available": has_ffmpeg},
+        {"id": "opus", "label": "Opus", "ext": ".opus", "available": has_ffmpeg},
+    ]
+    return {"formats": formats, "ffmpeg": has_ffmpeg}

openspeech/server/routes/webui.py

@@ -0,0 +1,29 @@
+"""Web UI static routes."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+router = APIRouter()
+
+_WEBUI_DIR = Path(__file__).resolve().parent.parent / "webui"
+
+
+@router.get("/ui")
+async def webui_index():
+    index = _WEBUI_DIR / "index.html"
+    if not index.exists():
+        raise HTTPException(status_code=404, detail="WebUI is not available")
+    return FileResponse(index)
+
+
+@router.get("/ui/{asset_name}")
+async def webui_asset(asset_name: str):
+    path = (_WEBUI_DIR / asset_name).resolve()
+    if _WEBUI_DIR not in path.parents and path != _WEBUI_DIR:
+        raise HTTPException(status_code=400, detail="Invalid path")
+    if not path.exists() or not path.is_file():
+        raise HTTPException(status_code=404, detail="Asset not found")
+    return FileResponse(path)