Download data/src/elevenlabs/speech_engine/server.py from introvoyz045/elevenlabs-python: direct link, hf CLI and curl.
- Browser
- Download file 6.2 kB
-
https://huggingface.co/datasets/introvoyz045/elevenlabs-python/resolve/main/data/src/elevenlabs/speech_engine/server.py
- Command line
-
hf download hf://datasets/introvoyz045/elevenlabs-python/data/src/elevenlabs/speech_engine/server.py
-
curl -L -o server.py https://huggingface.co/datasets/introvoyz045/elevenlabs-python/resolve/main/data/src/elevenlabs/speech_engine/server.py
6.2 kB
| """SpeechEngineServer — standalone WebSocket server for Speech Engine.""" | |
| import asyncio | |
| import http | |
| import os | |
| import typing | |
| import warnings | |
| from .session import SpeechEngineSession, _make_log, _wire_handlers | |
| from .types import WebSocketLike | |
| class SpeechEngineServer: | |
| """Standalone WebSocket server that produces :class:`SpeechEngineSession` | |
| instances for each incoming connection from the ElevenLabs Speech Engine | |
| API. | |
| Every incoming connection is verified against the ElevenLabs API using | |
| the configured API key before being accepted, unless ``disable_auth`` is | |
| set to ``True``. | |
| Example:: | |
| server = SpeechEngineServer( | |
| port=3001, | |
| api_key="sk_...", | |
| debug=True, | |
| on_transcript=handle_transcript, | |
| ) | |
| await server.serve() | |
| """ | |
| def __init__( | |
| self, | |
| *, | |
| port: int = 3001, | |
| path: typing.Optional[str] = None, | |
| api_key: typing.Optional[str] = None, | |
| debug: bool = False, | |
| disable_auth: bool = False, | |
| **handlers: typing.Any, | |
| ) -> None: | |
| """Initialize a Speech Engine server. | |
| :param disable_auth: If ``True``, skip verification of the | |
| ``X-Elevenlabs-Speech-Engine-Authorization`` JWT on incoming | |
| connections. **Insecure** — only enable this if the server is | |
| protected by an IP allowlist scoped to ElevenLabs' egress | |
| ranges. Without one, anyone on the internet can open a session | |
| and consume your compute and downstream LLM quota. | |
| """ | |
| self._port = port | |
| self._path = path | |
| self._api_key = api_key | |
| self._debug = debug | |
| self._disable_auth = disable_auth | |
| self._handlers = handlers | |
| self._stop_event = None # type: typing.Optional[asyncio.Event] | |
| self._server = None # type: typing.Any | |
| self._log = _make_log(debug) | |
| def handle_connection(self, ws: WebSocketLike) -> SpeechEngineSession: | |
| """Wrap *ws* in a :class:`SpeechEngineSession` with the server's | |
| handlers wired up. | |
| Use this when you manage your own WebSocket server and want to wrap | |
| individual connections. The returned session's :meth:`run` must | |
| still be awaited by the caller. | |
| """ | |
| self._log("creating new session") | |
| session = SpeechEngineSession(ws, debug=self._debug) | |
| _wire_handlers(session, self._handlers) | |
| return session | |
| async def serve(self) -> None: | |
| """Start the WebSocket server. Blocks until :meth:`stop` is called.""" | |
| from .resource import verify_speech_engine_jwt # noqa: E402 | |
| # Use the new asyncio API explicitly: `websockets.serve` was still | |
| # the legacy server on websockets 13.x and only became the asyncio | |
| # one in 14.0. The process_request callback below relies on the | |
| # asyncio signature (connection, request) and connection.respond(). | |
| from websockets.asyncio.server import serve as _ws_serve # noqa: E402 | |
| api_key = self._api_key or os.environ.get("ELEVENLABS_API_KEY") | |
| if not api_key and not self._disable_auth: | |
| raise RuntimeError( | |
| "SpeechEngineServer requires an API key to verify incoming " | |
| "connections. Pass api_key= or set the ELEVENLABS_API_KEY " | |
| "environment variable. To run without authentication, pass " | |
| "disable_auth=True — but only behind an IP allowlist." | |
| ) | |
| if self._disable_auth: | |
| warnings.warn( | |
| "SpeechEngineServer: authentication is disabled — incoming " | |
| "connections will NOT be verified. Make sure the server is " | |
| "protected by either IP allowlist restricting traffic to " | |
| "ElevenLabs or custom header values.", | |
| UserWarning, | |
| stacklevel=2, | |
| ) | |
| self._stop_event = asyncio.Event() | |
| def _process_request( | |
| connection: typing.Any, request: typing.Any | |
| ) -> typing.Any: | |
| if self._path is not None and request.path != self._path: | |
| self._log( | |
| "rejected connection — path mismatch: " | |
| "expected %s, got %s", | |
| self._path, | |
| request.path, | |
| ) | |
| return connection.respond( | |
| http.HTTPStatus.NOT_FOUND, "not found\n" | |
| ) | |
| if self._disable_auth: | |
| return None | |
| header_value = request.headers.get( | |
| "x-elevenlabs-speech-engine-authorization" | |
| ) | |
| if not header_value: | |
| self._log( | |
| "rejected connection — missing " | |
| "X-Elevenlabs-Speech-Engine-Authorization header" | |
| ) | |
| return connection.respond( | |
| http.HTTPStatus.UNAUTHORIZED, | |
| "missing authorization header\n", | |
| ) | |
| try: | |
| verify_speech_engine_jwt(header_value, typing.cast(str, api_key)) | |
| except ValueError as e: | |
| self._log("rejected connection — %s", e) | |
| return connection.respond( | |
| http.HTTPStatus.UNAUTHORIZED, | |
| "authorization failed\n", | |
| ) | |
| return None | |
| async def _handler(websocket: typing.Any) -> None: | |
| self._log("verified connection, accepting WebSocket") | |
| session = self.handle_connection(websocket) | |
| await session.run() | |
| self._server = await _ws_serve( | |
| _handler, | |
| "", | |
| self._port, | |
| process_request=_process_request, | |
| ) | |
| self._log("speech engine server listening on port %d", self._port) | |
| try: | |
| await self._stop_event.wait() | |
| finally: | |
| self._server.close() | |
| await self._server.wait_closed() | |
| async def stop(self) -> None: | |
| """Signal the server to shut down gracefully.""" | |
| if self._stop_event is not None: | |
| self._stop_event.set() | |