livekit-plugins-google 0.11.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

livekit/plugins/google/beta/realtime/transcriber.py

@@ -1,270 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import re
-from dataclasses import dataclass
-from typing import Literal
-
-import websockets
-from livekit import rtc
-from livekit.agents import APIConnectionError, APIStatusError, utils
-
-from google import genai
-from google.genai import types
-from google.genai.errors import APIError, ClientError, ServerError
-
-from ...log import logger
-from .api_proto import ClientEvents, LiveAPIModels
-
-EventTypes = Literal["input_speech_started", "input_speech_done"]
-
-DEFAULT_LANGUAGE = "English"
-
-SYSTEM_INSTRUCTIONS = f"""
-You are an **Audio Transcriber**. Your task is to convert audio content into accurate and precise text.
-- Transcribe verbatim; exclude non-speech sounds.
-- Provide only transcription; no extra text or explanations.
-- If audio is unclear, respond with: `...`
-- Ensure error-free transcription, preserving meaning and context.
-- Use proper punctuation and formatting.
-- Do not add explanations, comments, or extra information.
-- Do not include timestamps, speaker labels, or annotations unless specified.
-- Audio Language: {DEFAULT_LANGUAGE}
-"""
-
-
-@dataclass
-class TranscriptionContent:
-    response_id: str
-    text: str
-
-
-class TranscriberSession(utils.EventEmitter[EventTypes]):
-    """
-    Handles live audio transcription using the realtime API.
-    """
-
-    def __init__(self, *, client: genai.Client, model: LiveAPIModels | str):
-        super().__init__()
-        self._client = client
-        self._model = model
-        self._needed_sr = 16000
-        self._closed = False
-
-        system_instructions = types.Content(
-            parts=[types.Part(text=SYSTEM_INSTRUCTIONS)]
-        )
-        self._config = types.LiveConnectConfig(
-            response_modalities=[types.Modality.TEXT],
-            system_instruction=system_instructions,
-            generation_config=types.GenerationConfig(temperature=0.0),
-        )
-        self._main_atask = asyncio.create_task(
-            self._main_task(), name="gemini-realtime-transcriber"
-        )
-        self._send_ch = utils.aio.Chan[ClientEvents]()
-        self._resampler: rtc.AudioResampler | None = None
-        self._active_response_id = None
-
-    def _push_audio(self, frame: rtc.AudioFrame) -> None:
-        if self._closed:
-            return
-        if frame.sample_rate != self._needed_sr:
-            if not self._resampler:
-                self._resampler = rtc.AudioResampler(
-                    frame.sample_rate,
-                    self._needed_sr,
-                    quality=rtc.AudioResamplerQuality.HIGH,
-                )
-
-        if self._resampler:
-            for f in self._resampler.push(frame):
-                self._queue_msg(
-                    types.LiveClientRealtimeInput(
-                        media_chunks=[
-                            types.Blob(data=f.data.tobytes(), mime_type="audio/pcm")
-                        ]
-                    )
-                )
-        else:
-            self._queue_msg(
-                types.LiveClientRealtimeInput(
-                    media_chunks=[
-                        types.Blob(data=frame.data.tobytes(), mime_type="audio/pcm")
-                    ]
-                )
-            )
-
-    def _queue_msg(self, msg: ClientEvents) -> None:
-        if not self._closed:
-            self._send_ch.send_nowait(msg)
-
-    async def aclose(self) -> None:
-        if self._send_ch.closed:
-            return
-        self._closed = True
-        self._send_ch.close()
-        await self._main_atask
-
-    @utils.log_exceptions(logger=logger)
-    async def _main_task(self):
-        @utils.log_exceptions(logger=logger)
-        async def _send_task():
-            try:
-                async for msg in self._send_ch:
-                    if self._closed:
-                        break
-                    await self._session.send(input=msg)
-            except websockets.exceptions.ConnectionClosedError as e:
-                logger.exception(f"Transcriber session closed in _send_task: {e}")
-                self._closed = True
-            except Exception as e:
-                logger.exception(f"Uncaught error in transcriber _send_task: {e}")
-                self._closed = True
-
-        @utils.log_exceptions(logger=logger)
-        async def _recv_task():
-            try:
-                while not self._closed:
-                    async for response in self._session.receive():
-                        if self._closed:
-                            break
-                        if self._active_response_id is None:
-                            self._active_response_id = utils.shortuuid()
-                            content = TranscriptionContent(
-                                response_id=self._active_response_id,
-                                text="",
-                            )
-                            self.emit("input_speech_started", content)
-
-                        server_content = response.server_content
-                        if server_content:
-                            model_turn = server_content.model_turn
-                            if model_turn:
-                                for part in model_turn.parts:
-                                    if part.text:
-                                        content.text += part.text
-
-                            if server_content.turn_complete:
-                                content.text = clean_transcription(content.text)
-                                self.emit("input_speech_done", content)
-                                self._active_response_id = None
-
-            except websockets.exceptions.ConnectionClosedError as e:
-                logger.exception(f"Transcriber session closed in _recv_task: {e}")
-                self._closed = True
-            except Exception as e:
-                logger.exception(f"Uncaught error in transcriber _recv_task: {e}")
-                self._closed = True
-
-        async with self._client.aio.live.connect(
-            model=self._model, config=self._config
-        ) as session:
-            self._session = session
-            tasks = [
-                asyncio.create_task(
-                    _send_task(), name="gemini-realtime-transcriber-send"
-                ),
-                asyncio.create_task(
-                    _recv_task(), name="gemini-realtime-transcriber-recv"
-                ),
-            ]
-
-            try:
-                await asyncio.gather(*tasks)
-            finally:
-                await utils.aio.gracefully_cancel(*tasks)
-                await self._session.close()
-
-
-class ModelTranscriber(utils.EventEmitter[EventTypes]):
-    """
-    Transcribes agent audio using model generation.
-    """
-
-    def __init__(self, *, client: genai.Client, model: LiveAPIModels | str):
-        super().__init__()
-        self._client = client
-        self._model = model
-        self._needed_sr = 16000
-        self._system_instructions = types.Content(
-            parts=[types.Part(text=SYSTEM_INSTRUCTIONS)]
-        )
-        self._config = types.GenerateContentConfig(
-            temperature=0.0,
-            system_instruction=self._system_instructions,
-            # TODO: add response_schem
-        )
-        self._resampler: rtc.AudioResampler | None = None
-        self._buffer: rtc.AudioFrame | None = None
-        self._audio_ch = utils.aio.Chan[rtc.AudioFrame]()
-        self._main_atask = asyncio.create_task(
-            self._main_task(), name="gemini-model-transcriber"
-        )
-
-    async def aclose(self) -> None:
-        if self._audio_ch.closed:
-            return
-        self._audio_ch.close()
-        await self._main_atask
-
-    def _push_audio(self, frames: list[rtc.AudioFrame]) -> None:
-        if not frames:
-            return
-
-        buffer = utils.merge_frames(frames)
-
-        if buffer.sample_rate != self._needed_sr:
-            if self._resampler is None:
-                self._resampler = rtc.AudioResampler(
-                    input_rate=buffer.sample_rate,
-                    output_rate=self._needed_sr,
-                    quality=rtc.AudioResamplerQuality.HIGH,
-                )
-
-            buffer = utils.merge_frames(self._resampler.push(buffer))
-
-        self._audio_ch.send_nowait(buffer)
-
-    @utils.log_exceptions(logger=logger)
-    async def _main_task(self):
-        request_id = utils.shortuuid()
-        try:
-            async for buffer in self._audio_ch:
-                # TODO: stream content for better latency
-                response = await self._client.aio.models.generate_content(
-                    model=self._model,
-                    contents=[
-                        types.Content(
-                            parts=[
-                                types.Part(text=SYSTEM_INSTRUCTIONS),
-                                types.Part.from_bytes(
-                                    data=buffer.to_wav_bytes(),
-                                    mime_type="audio/wav",
-                                ),
-                            ],
-                            role="user",
-                        )
-                    ],
-                    config=self._config,
-                )
-                content = TranscriptionContent(
-                    response_id=request_id, text=clean_transcription(response.text)
-                )
-                self.emit("input_speech_done", content)
-
-        except (ClientError, ServerError, APIError) as e:
-            raise APIStatusError(
-                f"model transcriber error: {e}",
-                status_code=e.code,
-                body=e.message,
-                request_id=request_id,
-            ) from e
-        except Exception as e:
-            raise APIConnectionError("Error generating transcription") from e
-
-
-def clean_transcription(text: str) -> str:
-    text = text.replace("\n", " ")
-    text = re.sub(r"\s+", " ", text)
-    return text.strip()

livekit_plugins_google-0.11.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-livekit/plugins/google/__init__.py,sha256=e_kSlFNmKhyyeliz7f4WOKc_Y0-y39QjO5nCWuguhss,1171
-livekit/plugins/google/_utils.py,sha256=FG1_26nlWGcI6onPleQQcmGBMfb4QNYgis1B5BMJxWA,7131
-livekit/plugins/google/llm.py,sha256=LZaHsrkjfboRZLWm7L2G0mw62q2sXBNj4YeeV2Sk2uU,16717
-livekit/plugins/google/log.py,sha256=GI3YWN5YzrafnUccljzPRS_ZALkMNk1i21IRnTl2vNA,69
-livekit/plugins/google/models.py,sha256=SGjAumdDK97NNLwMFcqZdKR68f1NoGB2Rk1UP2-imG0,1457
-livekit/plugins/google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/google/stt.py,sha256=l6UB9oaM7eFInnI_0t7Ub-edXLVRgvaiyHj-e_gEuwE,22781
-livekit/plugins/google/tts.py,sha256=pG9_pibO3NDGEMa4huU5S9lbeyI3daQyrS17SuTKfZI,8008
-livekit/plugins/google/version.py,sha256=_06ctkD1XWTWec2BVgcsxun2sFLxqnvJJJs7ZxIBuHA,601
-livekit/plugins/google/beta/__init__.py,sha256=AxRYc7NGG62Tv1MmcZVCDHNvlhbC86hM-_yP01Qb28k,47
-livekit/plugins/google/beta/realtime/__init__.py,sha256=sGTn6JFNyA30QUXBZ_BV3l2eHpGAzR35ByXxg77vWNU,205
-livekit/plugins/google/beta/realtime/api_proto.py,sha256=9EhmwgeIgKDqdSijv5Q9pgx7UhAakK02ZDwbnUsra_o,657
-livekit/plugins/google/beta/realtime/realtime_api.py,sha256=8JdWUMUheGhy1ia6JbN3_U2_cL7CNs8-1fTOAgW4I38,22999
-livekit/plugins/google/beta/realtime/transcriber.py,sha256=rjXO0cSPr3HATxrSfv1MX7IbrjmiTvnLPF280BfRBL8,9809
-livekit_plugins_google-0.11.2.dist-info/METADATA,sha256=MQF9voerbBB1t5fGRw94z7jyfgJOnsM-DmWxtCT10V8,3732
-livekit_plugins_google-0.11.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-livekit_plugins_google-0.11.2.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
-livekit_plugins_google-0.11.2.dist-info/RECORD,,

livekit_plugins_google-0.11.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-livekit