livekit-agents 0.8.0.dev2__tar.gz → 0.8.0.dev8__tar.gz

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-agents
-Version: 0.8.0.dev2
+Version: 0.8.0.dev8
 Summary: LiveKit Python Agents
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -20,9 +20,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: click~=8.1
-Requires-Dist: livekit~=0.11
-Requires-Dist: livekit-api~=0.4
-Requires-Dist: livekit-protocol~=0.4
+Requires-Dist: livekit~=0.12.0.dev1
+Requires-Dist: livekit-api~=0.6.0
+Requires-Dist: livekit-protocol~=0.6.0
 Requires-Dist: protobuf>=3
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: types-protobuf<5,>=4

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/cli/watcher.py

@@ -75,7 +75,7 @@ class WatchServer:
         self._main_file = main_file
         self._loop = loop
 
-        self._recv_jobs_fut = asyncio.Future()
+        self._recv_jobs_fut = asyncio.Future[None]()
         self._reloading_jobs = False
 
     async def run(self) -> None:

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/ipc/channel.py

@@ -105,7 +105,7 @@ class AsyncProcChannel(ProcChannel):
 
         self._read_q = asyncio.Queue[Optional[Message]]()
         self._write_q = queue.Queue[Optional[Message]]()
-        self._exit_fut = asyncio.Future()
+        self._exit_fut = asyncio.Future[None]()
 
         self._read_t = threading.Thread(
             target=self._read_thread, daemon=True, name="proc_channel_read"

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/ipc/proc_main.py

@@ -118,12 +118,15 @@ def _start_job(
         await room.disconnect()
 
         try:
-            job_shutdown_task = asyncio.create_task(
-                args.job_shutdown_fnc(job_ctx), name="job_shutdown"
-            )
-            await job_shutdown_task
+            shutdown_tasks = []
+            for callback in job_ctx._shutdown_callbacks:
+                shutdown_tasks.append(
+                    asyncio.create_task(callback(), name="job_shutdown_callback")
+                )
+
+            await asyncio.gather(*shutdown_tasks)
         except Exception:
-            logger.exception("error while disconnecting room")
+            logger.exception("error while shutting down the job")
 
         await utils.http_context._close_http_ctx()
         exit_proc_fut.set()
@@ -157,9 +160,10 @@ async def _async_main(
 
                 if isinstance(msg, proto.ShutdownRequest):
                     if job_task is not None:
-                        job_task.shutdown_fut.set_result(
-                            _ShutdownInfo(reason=msg.reason, user_initiated=False)
-                        )
+                        with contextlib.suppress(asyncio.InvalidStateError):
+                            job_task.shutdown_fut.set_result(
+                                _ShutdownInfo(reason=msg.reason, user_initiated=False)
+                            )
                     else:
                         exit_proc_fut.set()  # there is no running job, we can exit immediately
 
@@ -210,8 +214,9 @@ def main(args: proto.ProcStartArgs) -> None:
             # (this signal can be sent by watchfiles on dev mode)
             loop.run_until_complete(main_task)
     finally:
-        try:
-            loop.run_until_complete(loop.shutdown_default_executor())
-            #loop.run_until_complete(cch.aclose())
-        finally:
-            loop.close()
+        # try:
+        loop.run_until_complete(loop.shutdown_default_executor())
+        loop.run_until_complete(cch.aclose())
+        # finally:
+        # loop.close()
+        # pass

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/ipc/proc_pool.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-import multiprocessing as mp
-import sys
+from multiprocessing.context import BaseContext
 from typing import Any, Callable, Coroutine, Literal
 
 from .. import utils
@@ -22,22 +21,16 @@ class ProcPool(utils.EventEmitter[EventTypes]):
         *,
         initialize_process_fnc: Callable[[JobProcess], Any],
         job_entrypoint_fnc: Callable[[JobContext], Coroutine],
-        job_shutdown_fnc: Callable[[JobContext], Coroutine],
         num_idle_processes: int,
         initialize_timeout: float,
         close_timeout: float,
+        mp_ctx: BaseContext,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         super().__init__()
-
-        #if sys.platform.startswith("linux"):
-        #    self._mp_ctx = mp.get_context("forkserver")
-        #else:
-        self._mp_ctx = mp.get_context("spawn")
-
+        self._mp_ctx = mp_ctx
         self._initialize_process_fnc = initialize_process_fnc
         self._job_entrypoint_fnc = job_entrypoint_fnc
-        self._job_shutdown_fnc = job_shutdown_fnc
         self._close_timeout = close_timeout
         self._initialize_timeout = initialize_timeout
         self._loop = loop
@@ -74,7 +67,6 @@ class ProcPool(utils.EventEmitter[EventTypes]):
         proc = SupervisedProc(
             initialize_process_fnc=self._initialize_process_fnc,
             job_entrypoint_fnc=self._job_entrypoint_fnc,
-            job_shutdown_fnc=self._job_shutdown_fnc,
             initialize_timeout=self._initialize_timeout,
             close_timeout=self._close_timeout,
             mp_ctx=self._mp_ctx,

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/ipc/proto.py

@@ -19,7 +19,6 @@ HIGH_PING_THRESHOLD = 0.02  # 20ms
 class ProcStartArgs:
     initialize_process_fnc: Callable[[JobProcess], Any]
     job_entrypoint_fnc: Callable[[JobContext], Coroutine]
-    job_shutdown_fnc: Callable[[JobContext], Coroutine]
     log_q: mp.Queue
     mp_cch: channel.ProcessConn
     asyncio_debug: bool

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/ipc/supervised_proc.py

@@ -6,7 +6,7 @@ import logging
 import multiprocessing as mp
 import sys
 import threading
-from multiprocessing.context import ForkServerContext, SpawnContext
+from multiprocessing.context import BaseContext
 from typing import Any, Callable, Coroutine
 
 from .. import utils
@@ -32,6 +32,8 @@ class LogQueueListener:
         t.start()
 
     def stop(self) -> None:
+        if self._thread is None:
+            return
         self._q.put_nowait(self._sentinel)
         self._thread.join()
         self._thread = None
@@ -60,14 +62,13 @@ class SupervisedProc:
         *,
         initialize_process_fnc: Callable[[JobProcess], Any],
         job_entrypoint_fnc: Callable[[JobContext], Coroutine],
-        job_shutdown_fnc: Callable[[JobContext], Coroutine],
         initialize_timeout: float,
         close_timeout: float,
-        mp_ctx: SpawnContext | ForkServerContext,
+        mp_ctx: BaseContext,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         self._loop = loop
-        log_q = mp.Queue()
+        log_q = mp_ctx.Queue()
         log_q.cancel_join_thread()
         mp_pch, mp_cch = mp_ctx.Pipe(duplex=True)
 
@@ -80,13 +81,12 @@ class SupervisedProc:
         self._proc_args = proto.ProcStartArgs(
             initialize_process_fnc=initialize_process_fnc,
             job_entrypoint_fnc=job_entrypoint_fnc,
-            job_shutdown_fnc=job_shutdown_fnc,
             log_q=log_q,
             mp_cch=mp_cch,
             asyncio_debug=loop.get_debug(),
         )
 
-        self._proc = mp_ctx.Process(
+        self._proc = mp_ctx.Process(  # type: ignore
             target=proc_main.main, args=(self._proc_args,), name="job_proc"
         )
         self._running_job: RunningJobInfo | None = None
@@ -97,7 +97,7 @@ class SupervisedProc:
         self._main_atask: asyncio.Task[None] | None = None
         self._closing = False
         self._kill_sent = False
-        self._initialize_fut = asyncio.Future()
+        self._initialize_fut = asyncio.Future[None]()
 
     @property
     def exitcode(self) -> int | None:
@@ -145,7 +145,7 @@ class SupervisedProc:
 
         self._proc.start()
         self._pid = self._proc.pid
-        self._join_fut = asyncio.Future()
+        self._join_fut = asyncio.Future[None]()
 
         def _sync_run():
             self._proc.join()
@@ -161,7 +161,8 @@ class SupervisedProc:
         if not self.started:
             raise RuntimeError("process not started")
 
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def initialize(self) -> None:
         """initialize the job process, this is calling the user provided initialize_process_fnc
@@ -198,16 +199,18 @@ class SupervisedProc:
             await self._pch.asend(proto.ShutdownRequest())
 
         try:
-            await asyncio.wait_for(
-                asyncio.shield(self._main_atask), timeout=self._close_timeout
-            )
+            if self._main_atask:
+                await asyncio.wait_for(
+                    asyncio.shield(self._main_atask), timeout=self._close_timeout
+                )
         except asyncio.TimeoutError:
             logger.error(
                 "process did not exit in time, killing job", extra=self.logging_extra()
             )
             self._send_kill_signal()
 
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def kill(self) -> None:
         """forcefully kill the job process"""
@@ -216,7 +219,8 @@ class SupervisedProc:
 
         self._closing = True
         self._send_kill_signal()
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def launch_job(self, info: RunningJobInfo) -> None:
         """start/assign a job to the process"""
@@ -230,7 +234,10 @@ class SupervisedProc:
 
     def _send_kill_signal(self) -> None:
         """forcefully kill the job process"""
-        if not self._proc.is_alive():
+        try:
+            if not self._proc.is_alive():
+                return
+        except ValueError:
             return
 
         logger.debug("killing job process", extra=self.logging_extra())

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/job.py

@@ -61,6 +61,7 @@ class JobContext:
         self._room = room
         self._on_connect = on_connect
         self._on_shutdown = on_shutdown
+        self._shutdown_callbacks: list[Callable[[], Coroutine]] = []
 
     @property
     def proc(self) -> JobProcess:
@@ -78,6 +79,9 @@ class JobContext:
     def agent(self) -> rtc.LocalParticipant:
         return self._room.local_participant
 
+    def add_shutdown_callback(self, callback: Callable[[], Coroutine]) -> None:
+        self._shutdown_callbacks.append(callback)
+
     async def connect(
         self,
         *,
@@ -114,8 +118,8 @@ def _apply_auto_subscribe_opts(room: rtc.Room, auto_subscribe: AutoSubscribe) ->
         ):
             pub.set_subscribed(True)
 
-    for p in room.participants.values():
-        for pub in p.tracks.values():
+    for p in room.remote_participants.values():
+        for pub in p.track_publications.values():
             _subscribe_if_needed(pub)
 
     @room.on("track_published")
@@ -128,11 +132,11 @@ def _apply_auto_subscribe_opts(room: rtc.Room, auto_subscribe: AutoSubscribe) ->
 class JobProcess:
     def __init__(self, *, start_arguments: Any | None = None) -> None:
         self._mp_proc = mp.current_process()
-        self._userdata = {}
+        self._userdata: dict[str, Any] = {}
         self._start_arguments = start_arguments
 
     @property
-    def pid(self) -> int:
+    def pid(self) -> int | None:
         return self._mp_proc.pid
 
     @property

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/stt/stt.py

@@ -12,7 +12,7 @@ from ..utils import AudioBuffer, aio
 
 
 @unique
-class SpeechEventType(Enum):
+class SpeechEventType(str, Enum):
     START_OF_SPEECH = "start_of_speech"
     """indicate the start of speech
     if the STT doesn't support this event, this will be emitted as the same time as the first INTERIM_TRANSCRIPT"""

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/transcription/_utils.py

@@ -7,7 +7,7 @@ from livekit import rtc
 
 def find_micro_track_id(room: rtc.Room, identity: str) -> str:
     p: rtc.RemoteParticipant | rtc.LocalParticipant | None = (
-        room.participants_by_identity.get(identity)
+        room.remote_participants.get(identity)
     )
     if identity == room.local_participant.identity:
         p = room.local_participant
@@ -17,7 +17,7 @@ def find_micro_track_id(room: rtc.Room, identity: str) -> str:
 
     # find first micro track
     track_id = None
-    for track in p.tracks.values():
+    for track in p.track_publications.values():
         if track.source == rtc.TrackSource.SOURCE_MICROPHONE:
             track_id = track.sid
             break

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/transcription/stt_forwarder.py

@@ -45,9 +45,8 @@ class STTSegmentsForwarder:
 
                 transcription = rtc.Transcription(
                     participant_identity=self._participant_identity,
-                    track_id=self._track_id,
+                    track_sid=self._track_id,
                     segments=[seg],  # no history for now
-                    language="",  # TODO(theomonnom)
                 )
                 await self._room.local_participant.publish_transcription(transcription)
 
@@ -66,13 +65,19 @@ class STTSegmentsForwarder:
                     start_time=0,
                     end_time=0,
                     final=False,
+                    language="",  # TODO
                 )
             )
         elif ev.type == stt.SpeechEventType.FINAL_TRANSCRIPT:
             text = ev.alternatives[0].text
             self._queue.put_nowait(
                 rtc.TranscriptionSegment(
-                    id=self._current_id, text=text, start_time=0, end_time=0, final=True
+                    id=self._current_id,
+                    text=text,
+                    start_time=0,
+                    end_time=0,
+                    final=True,
+                    language="",  # TODO
                 )
             )
 

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/transcription/tts_forwarder.py

@@ -13,6 +13,9 @@ from .. import tokenize, utils
 from ..log import logger
 from . import _utils
 
+# 3.83 is the "baseline", the number of hyphens per second TTS returns in avg.
+STANDARD_SPEECH_RATE = 3.83
+
 
 @dataclass
 class _TTSOptions:
@@ -35,7 +38,7 @@ class _SegmentData:
     pushed_duration: float = 0.0
     real_speed: float | None = None
     processed_sentences: int = 0
-    processed_hyphenes: int = 0
+    processed_hyphens: int = 0
     validated: bool = False
     forward_start_time: float | None = 0.0
 
@@ -62,7 +65,7 @@ class TTSSegmentsForwarder:
         participant: rtc.Participant | str,
         track: rtc.Track | rtc.TrackPublication | str | None = None,
         language: str = "",
-        speed: float = 3.83,
+        speed: float = 1.0,
         new_sentence_delay: float = 0.4,
         word_tokenizer: tokenize.WordTokenizer = tokenize.basic.WordTokenizer(),
         sentence_tokenizer: tokenize.SentenceTokenizer = tokenize.basic.SentenceTokenizer(),
@@ -82,7 +85,7 @@ class TTSSegmentsForwarder:
                 to start the transcription.
             word_tokenizer: word tokenizer used to split the text into words
             sentence_tokenizer: sentence tokenizer used to split the text into sentences
-            hyphenate_word: function that returns a list of hyphenes for a given word
+            hyphenate_word: function that returns a list of hyphens for a given word
 
         """
         identity = participant if isinstance(participant, str) else participant.identity
@@ -92,6 +95,7 @@ class TTSSegmentsForwarder:
         elif isinstance(track, (rtc.TrackPublication, rtc.Track)):
             track = track.sid
 
+        speed = speed * STANDARD_SPEECH_RATE
         self._opts = _TTSOptions(
             room=room,
             participant_identity=identity,
@@ -185,6 +189,10 @@ class TTSSegmentsForwarder:
         self._forming_segments.q.append(new_seg)
         self._seg_queue.put_nowait(new_seg)
 
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
     async def aclose(self) -> None:
         if self._closed:
             return
@@ -213,9 +221,8 @@ class TTSSegmentsForwarder:
 
                 tr = rtc.Transcription(
                     participant_identity=self._opts.participant_identity,
-                    track_id=self._opts.track_id,
+                    track_sid=self._opts.track_id,
                     segments=[seg],  # no history for now, only one segment
-                    language=self._opts.language,
                 )
                 await self._opts.room.local_participant.publish_transcription(tr)
 
@@ -267,7 +274,7 @@ class TTSSegmentsForwarder:
                 # transcription closed, early
                 return
 
-            word_hyphenes = len(self._opts.hyphenate_word(word))
+            word_hyphens = len(self._opts.hyphenate_word(word))
             processed_words.append(word)
 
             # elapsed time since the start of the seg
@@ -283,26 +290,36 @@ class TTSSegmentsForwarder:
                 )
                 hyph_pauses = estimated_pauses_s * speed
 
-                target_hyphenes = round(speed * elapsed_time)
-                dt = target_hyphenes - seg.processed_hyphenes - hyph_pauses
-                to_wait_hyphenes = max(0, word_hyphenes - dt)
-                delay = to_wait_hyphenes / speed
+                target_hyphens = round(speed * elapsed_time)
+                dt = target_hyphens - seg.processed_hyphens - hyph_pauses
+                to_wait_hyphens = max(0, word_hyphens - dt)
+                delay = to_wait_hyphens / speed
             else:
-                delay = word_hyphenes / speed
+                delay = word_hyphens / speed
 
             first_delay = min(delay / 2, 2 / speed)
             await self._sleep_if_not_closed(first_delay)
             rtc_seg_q.put_nowait(
                 rtc.TranscriptionSegment(
-                    id=seg_id, text=text, start_time=0, end_time=0, final=False
+                    id=seg_id,
+                    text=text,
+                    start_time=0,
+                    end_time=0,
+                    final=False,
+                    language=self._opts.language,
                 )
             )
             await self._sleep_if_not_closed(delay - first_delay)
-            seg.processed_hyphenes += word_hyphenes
+            seg.processed_hyphens += word_hyphens
 
         rtc_seg_q.put_nowait(
             rtc.TranscriptionSegment(
-                id=seg_id, text=tokenized_sentence, start_time=0, end_time=0, final=True
+                id=seg_id,
+                text=tokenized_sentence,
+                start_time=0,
+                end_time=0,
+                final=True,
+                language=self._opts.language,
             )
         )
 
@@ -314,13 +331,13 @@ class TTSSegmentsForwarder:
             await asyncio.wait([self._close_future], timeout=delay)
 
     def _calc_hyphens(self, text: str) -> list[str]:
-        hyphenes: list[str] = []
+        hyphens: list[str] = []
         words = self._opts.word_tokenizer.tokenize(text=text)
         for word in words:
             new = self._opts.hyphenate_word(word)
-            hyphenes.extend(new)
+            hyphens.extend(new)
 
-        return hyphenes
+        return hyphens
 
     def _create_segment(self) -> _SegmentData:
         data = _SegmentData(

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/utils/aio/__init__.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 
 from . import debug
 from .channel import Chan, ChanClosed, ChanReceiver, ChanSender
@@ -11,7 +12,8 @@ async def gracefully_cancel(*futures: asyncio.Future):
     for f in futures:
         f.cancel()
 
-    await asyncio.gather(*futures, return_exceptions=True)
+    with contextlib.suppress(asyncio.CancelledError):
+        await asyncio.gather(*futures)
 
 
 __all__ = [

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/vad.py

@@ -10,7 +10,7 @@ from .utils import aio
 
 
 @unique
-class VADEventType(Enum):
+class VADEventType(str, Enum):
     START_OF_SPEECH = "start_of_speech"
     INFERENCE_DONE = "inference_done"
     END_OF_SPEECH = "end_of_speech"
@@ -42,8 +42,8 @@ class VADCapabilities:
 
 
 class VAD(ABC):
-    def __init__(self, *, capatiilities: VADCapabilities) -> None:
-        self._capabilities = capatiilities
+    def __init__(self, *, capabilities: VADCapabilities) -> None:
+        self._capabilities = capabilities
 
     @property
     def capabilities(self) -> VADCapabilities:

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev8}/livekit/agents/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.8.0-dev.2"
+__version__ = "0.8.0-dev.8"