data

Author: bcherry

examples/rpc.py

@@ -3,7 +3,8 @@
 import json
 import asyncio
 from dotenv import load_dotenv
-from livekit.rtc.rpc import RpcHandlerParams
+from livekit.rtc.rpc import RpcInvocationData
+
 load_dotenv(dotenv_path=".env.local", override=False)
 LIVEKIT_API_KEY = os.getenv("LIVEKIT_API_KEY")
 LIVEKIT_API_SECRET = os.getenv("LIVEKIT_API_SECRET")
@@ -90,20 +91,20 @@ async def main():
 def register_receiver_methods(greeters_room: rtc.Room, math_genius_room: rtc.Room):
     @greeters_room.local_participant.rpc_method("arrival")
     async def arrival_method(
-        params: RpcHandlerParams,
+        data: RpcInvocationData,
     ):
-        print(f'[Greeter] Oh {params.caller_identity} arrived and said "{params.payload}"')
+        print(f'[Greeter] Oh {data.caller_identity} arrived and said "{data.payload}"')
         await asyncio.sleep(2)
         return "Welcome and have a wonderful day!"
 
     @math_genius_room.local_participant.rpc_method("square-root")
     async def square_root_method(
-        params: RpcHandlerParams,
+        data: RpcInvocationData,
     ):
-        json_data = json.loads(params.payload)
+        json_data = json.loads(data.payload)
         number = json_data["number"]
         print(
-            f"[Math Genius] I guess {params.caller_identity} wants the square root of {number}. I've only got {params.response_timeout} seconds to respond but I think I can pull it off."
+            f"[Math Genius] I guess {data.caller_identity} wants the square root of {number}. I've only got {data.response_timeout} seconds to respond but I think I can pull it off."
         )
 
         print("[Math Genius] *doing math*…")
@@ -115,25 +116,27 @@ async def square_root_method(
 
     @math_genius_room.local_participant.rpc_method("divide")
     async def divide_method(
-        params: RpcHandlerParams,
+        data: RpcInvocationData,
     ):
-        json_data = json.loads(params.payload)
+        json_data = json.loads(data.payload)
         dividend = json_data["dividend"]
         divisor = json_data["divisor"]
         print(
-            f"[Math Genius] {params.caller_identity} wants to divide {dividend} by {divisor}."
+            f"[Math Genius] {data.caller_identity} wants to divide {dividend} by {divisor}."
         )
 
         result = dividend / divisor
         return json.dumps({"result": result})
 
     @math_genius_room.local_participant.rpc_method("long-calculation")
     async def long_calculation_method(
-        params: RpcHandlerParams,
+        data: RpcInvocationData,
     ):
-        print(f"[Math Genius] Starting a very long calculation for {params.caller_identity}")
         print(
-            f"[Math Genius] This will take 30 seconds even though you're only giving me {params.response_timeout} seconds"
+            f"[Math Genius] Starting a very long calculation for {data.caller_identity}"
+        )
+        print(
+            f"[Math Genius] This will take 30 seconds even though you're only giving me {data.response_timeout} seconds"
         )
         await asyncio.sleep(30)
         return json.dumps({"result": "Calculation complete!"})

livekit-rtc/livekit/rtc/participant.py

@@ -40,7 +40,8 @@
 from .log import logger
 import asyncio
 
-from .rpc import RpcHandlerParams
+from .rpc import RpcInvocationData
+
 
 class PublishTrackError(Exception):
     def __init__(self, message: str) -> None:
@@ -119,7 +120,7 @@ def __init__(
         self._room_queue = room_queue
         self._track_publications: dict[str, LocalTrackPublication] = {}  # type: ignore
         self._rpc_handlers: Dict[
-            str, Callable[[RpcHandlerParams], Union[Awaitable[str], str]]
+            str, Callable[[RpcInvocationData], Union[Awaitable[str], str]]
         ] = {}
 
     @property
@@ -292,7 +293,7 @@ async def perform_rpc(
     def register_rpc_method(
         self,
         method: str,
-        handler: Callable[[RpcHandlerParams], Union[Awaitable[str], str]],
+        handler: Callable[[RpcInvocationData], Union[Awaitable[str], str]],
     ) -> None:
         """
         Establishes the participant as a receiver for calls of the specified RPC method.
@@ -309,14 +310,14 @@ def register_rpc_method(
             RpcError: On failure. Details in `message`.
 
         Example:
-            async def greet_handler(params: RpcHandlerParams) -> str:
-                print(f"Received greeting from {params.caller_identity}: {params.payload}")
-                return f"Hello, {params.caller_identity}!"
+            async def greet_handler(data: RpcInvocationData) -> str:
+                print(f"Received greeting from {data.caller_identity}: {data.payload}")
+                return f"Hello, {data.caller_identity}!"
 
             await room.local_participant.register_rpc_method('greet', greet_handler)
 
         The handler should return a string or a coroutine that resolves to a string.
-        
+
         If unable to respond within `response_timeout`, the caller will hang up and receive an error on their side.
 
         You may raise errors of type `RpcError` with a string `message` in the handler,
@@ -340,16 +341,16 @@ def rpc_method(self, method: str):
 
         Example:
             @local_participant.rpc_method("greet")
-            async def greet_handler(params: RpcHandlerParams) -> str:
-                print(f"Received greeting from {params.caller_identity}: {params.payload}")
+            async def greet_handler(data: RpcInvocationData) -> str:
+                print(f"Received greeting from {data.caller_identity}: {data.payload}")
                 return f"Hello, {params.caller_identity}!"
 
         See Also:
             `register_rpc_method` for more details
         """
 
         def decorator(
-            handler: Callable[[RpcHandlerParams], Union[Awaitable[str], str]],
+            handler: Callable[[RpcInvocationData], Union[Awaitable[str], str]],
         ):
             self.register_rpc_method(method, handler)
             return handler
@@ -382,8 +383,10 @@ async def _handle_rpc_method_invocation(
     ) -> None:
         response_error: Optional[RpcError] = None
         response_payload: Optional[str] = None
-        
-        params = RpcHandlerParams(request_id, caller_identity, payload, response_timeout)
+
+        params = RpcInvocationData(
+            request_id, caller_identity, payload, response_timeout
+        )
 
         handler = self._rpc_handlers.get(method)
 
@@ -392,7 +395,7 @@ async def _handle_rpc_method_invocation(
         else:
             try:
                 if asyncio.iscoroutinefunction(handler):
-                    async_handler = handler  # type: Callable[[RpcHandlerParams], Awaitable[str]]
+                    async_handler = handler  # type: Callable[[RpcInvocationData], Awaitable[str]]
 
                     async def run_handler():
                         try:
@@ -412,7 +415,7 @@ async def run_handler():
                             RpcError.ErrorCode.RECIPIENT_DISCONNECTED
                         )
                 else:
-                    sync_handler = handler  # type: Callable[[RpcHandlerParams], str]
+                    sync_handler = handler  # type: Callable[[RpcInvocationData], str]
                     response_payload = sync_handler(params)
             except RpcError as error:
                 response_error = error

livekit-rtc/livekit/rtc/rpc.py

@@ -17,16 +17,18 @@
 from ._proto import rpc_pb2 as proto_rpc
 from dataclasses import dataclass
 
+
 @dataclass
-class RpcHandlerParams:
-    """Parameters passed to method handler for incoming RPC invocations
-    
+class RpcInvocationData:
+    """Data passed to method handler for incoming RPC invocations
+
     Attributes:
         request_id (str): The unique request ID. Will match at both sides of the call, useful for debugging or logging.
         caller_identity (str): The unique participant identity of the caller.
         payload (str): The payload of the request. User-definable format, typically JSON.
         response_timeout (float): The maximum time the caller will wait for a response.
     """
+
     request_id: str
     caller_identity: str
     payload: str