livekit-api 0.8.2__tar.gz → 1.0.1__tar.gz

{livekit_api-0.8.2 → livekit_api-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: livekit-api
-Version: 0.8.2
+Version: 1.0.1
 Summary: Python Server API for LiveKit
 Home-page: https://github.com/livekit/python-sdks
 License: Apache-2.0
@@ -23,9 +23,9 @@ Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: protobuf>=3
-Requires-Dist: types-protobuf<5,>=4
-Requires-Dist: livekit-protocol<2,>=0.8.2
+Requires-Dist: protobuf>=4
+Requires-Dist: types-protobuf>=4
+Requires-Dist: livekit-protocol~=1.0
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/__init__.py

@@ -52,4 +52,6 @@ __all__ = [
     "AccessToken",
     "TokenVerifier",
     "WebhookReceiver",
+    "TwirpError",
+    "TwirpErrorCode",
 ]

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/_service.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict
 import aiohttp
 from abc import ABC
 from .twirp_client import TwirpClient
@@ -10,16 +9,14 @@ AUTHORIZATION = "authorization"
 
 
 class Service(ABC):
-    def __init__(
-        self, session: aiohttp.ClientSession, host: str, api_key: str, api_secret: str
-    ):
+    def __init__(self, session: aiohttp.ClientSession, host: str, api_key: str, api_secret: str):
         self._client = TwirpClient(session, host, "livekit")
         self.api_key = api_key
         self.api_secret = api_secret
 
     def _auth_header(
         self, grants: VideoGrants | None, sip: SIPGrants | None = None
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         tok = AccessToken(self.api_key, self.api_secret)
         if grants:
             tok.with_grants(grants)

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/access_token.py

@@ -91,9 +91,7 @@ class Claims:
         claims = dataclasses.asdict(
             self,
             dict_factory=lambda items: {
-                snake_to_lower_camel(k): v
-                for k, v in items
-                if v is not None and v != ""
+                snake_to_lower_camel(k): v for k, v in items if v is not None and v != ""
             },
         )
         if self.room_config:
@@ -178,13 +176,9 @@ class AccessToken:
             {
                 "sub": self.identity,
                 "iss": self.api_key,
-                "nbf": calendar.timegm(
-                    datetime.datetime.now(datetime.timezone.utc).utctimetuple()
-                ),
+                "nbf": calendar.timegm(datetime.datetime.now(datetime.timezone.utc).utctimetuple()),
                 "exp": calendar.timegm(
-                    (
-                        datetime.datetime.now(datetime.timezone.utc) + self.ttl
-                    ).utctimetuple()
+                    (datetime.datetime.now(datetime.timezone.utc) + self.ttl).utctimetuple()
                 ),
             }
         )
@@ -220,16 +214,12 @@ class TokenVerifier:
 
         video_dict = claims.get("video", dict())
         video_dict = {camel_to_snake(k): v for k, v in video_dict.items()}
-        video_dict = {
-            k: v for k, v in video_dict.items() if k in VideoGrants.__dataclass_fields__
-        }
+        video_dict = {k: v for k, v in video_dict.items() if k in VideoGrants.__dataclass_fields__}
         video = VideoGrants(**video_dict)
 
         sip_dict = claims.get("sip", dict())
         sip_dict = {camel_to_snake(k): v for k, v in sip_dict.items()}
-        sip_dict = {
-            k: v for k, v in sip_dict.items() if k in SIPGrants.__dataclass_fields__
-        }
+        sip_dict = {k: v for k, v in sip_dict.items() if k in SIPGrants.__dataclass_fields__}
         sip = SIPGrants(**sip_dict)
 
         grant_claims = Claims(
@@ -259,6 +249,4 @@ def camel_to_snake(t: str):
 
 
 def snake_to_lower_camel(t: str):
-    return "".join(
-        word.capitalize() if i else word for i, word in enumerate(t.split("_"))
-    )
+    return "".join(word.capitalize() if i else word for i, word in enumerate(t.split("_")))

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/agent_dispatch_service.py

@@ -26,9 +26,7 @@ class AgentDispatchService(Service):
     ```
     """
 
-    def __init__(
-        self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str
-    ):
+    def __init__(self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str):
         super().__init__(session, url, api_key, api_secret)
 
     async def create_dispatch(self, req: CreateAgentDispatchRequest) -> AgentDispatch:
@@ -89,9 +87,7 @@ class AgentDispatchService(Service):
         )
         return list(res.agent_dispatches)
 
-    async def get_dispatch(
-        self, dispatch_id: str, room_name: str
-    ) -> Optional[AgentDispatch]:
+    async def get_dispatch(self, dispatch_id: str, room_name: str) -> Optional[AgentDispatch]:
         """Get an Agent dispatch by ID
 
         Args:

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/egress_service.py

@@ -33,14 +33,11 @@ class EgressService(Service):
     Also see https://docs.livekit.io/home/egress/overview/
     """
 
-    def __init__(
-        self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str
-    ):
+    def __init__(self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str):
         super().__init__(session, url, api_key, api_secret)
 
-    async def start_room_composite_egress(
-        self, start: RoomCompositeEgressRequest
-    ) -> EgressInfo:
+    async def start_room_composite_egress(self, start: RoomCompositeEgressRequest) -> EgressInfo:
+        """Starts a composite recording of a room."""
         return await self._client.request(
             SVC,
             "StartRoomCompositeEgress",
@@ -50,6 +47,7 @@ class EgressService(Service):
         )
 
     async def start_web_egress(self, start: WebEgressRequest) -> EgressInfo:
+        """Starts a recording of a web page."""
         return await self._client.request(
             SVC,
             "StartWebEgress",
@@ -58,9 +56,8 @@ class EgressService(Service):
             EgressInfo,
         )
 
-    async def start_participant_egress(
-        self, start: ParticipantEgressRequest
-    ) -> EgressInfo:
+    async def start_participant_egress(self, start: ParticipantEgressRequest) -> EgressInfo:
+        """Starts a recording of a participant."""
         return await self._client.request(
             SVC,
             "StartParticipantEgress",
@@ -69,9 +66,8 @@ class EgressService(Service):
             EgressInfo,
         )
 
-    async def start_track_composite_egress(
-        self, start: TrackCompositeEgressRequest
-    ) -> EgressInfo:
+    async def start_track_composite_egress(self, start: TrackCompositeEgressRequest) -> EgressInfo:
+        """Starts a composite recording with audio and video tracks."""
         return await self._client.request(
             SVC,
             "StartTrackCompositeEgress",
@@ -81,6 +77,7 @@ class EgressService(Service):
         )
 
     async def start_track_egress(self, start: TrackEgressRequest) -> EgressInfo:
+        """Starts a recording of a single track."""
         return await self._client.request(
             SVC,
             "StartTrackEgress",
@@ -90,6 +87,7 @@ class EgressService(Service):
         )
 
     async def update_layout(self, update: UpdateLayoutRequest) -> EgressInfo:
+        """Updates the layout of a composite recording."""
         return await self._client.request(
             SVC,
             "UpdateLayout",
@@ -99,6 +97,7 @@ class EgressService(Service):
         )
 
     async def update_stream(self, update: UpdateStreamRequest) -> EgressInfo:
+        """Updates the stream of a RoomComposite, Web, or Participant recording."""
         return await self._client.request(
             SVC,
             "UpdateStream",
@@ -108,6 +107,14 @@ class EgressService(Service):
         )
 
     async def list_egress(self, list: ListEgressRequest) -> ListEgressResponse:
+        """Lists all active egress and recently completed recordings.
+
+        Args:
+            list (ListEgressRequest): arg contains optional filters:
+                - room_name: str - List all egresses for a specific room
+                - egress_id: str - Only list egress with matching ID
+                - active: bool - Only list active egresses
+        """
         return await self._client.request(
             SVC,
             "ListEgress",
@@ -117,6 +124,7 @@ class EgressService(Service):
         )
 
     async def stop_egress(self, stop: StopEgressRequest) -> EgressInfo:
+        """Stops an active egress recording."""
         return await self._client.request(
             SVC,
             "StopEgress",

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/ingress_service.py

@@ -28,9 +28,7 @@ class IngressService(Service):
     Also see https://docs.livekit.io/home/ingress/overview/
     """
 
-    def __init__(
-        self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str
-    ):
+    def __init__(self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str):
         super().__init__(session, url, api_key, api_secret)
 
     async def create_ingress(self, create: CreateIngressRequest) -> IngressInfo:

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/livekit_api.py

@@ -28,7 +28,8 @@ class LiveKitAPI:
         api_key: Optional[str] = None,
         api_secret: Optional[str] = None,
         *,
-        timeout: aiohttp.ClientTimeout = aiohttp.ClientTimeout(total=60),  # 60 seconds
+        timeout: Optional[aiohttp.ClientTimeout] = None,
+        session: Optional[aiohttp.ClientSession] = None,
     ):
         """Create a new LiveKitAPI instance.
 
@@ -37,6 +38,7 @@ class LiveKitAPI:
             api_key: API key (read from `LIVEKIT_API_KEY` environment variable if not provided)
             api_secret: API secret (read from `LIVEKIT_API_SECRET` environment variable if not provided)
             timeout: Request timeout (default: 60 seconds)
+            session: aiohttp.ClientSession instance to use for requests, if not provided, a new one will be created
         """
         url = url or os.getenv("LIVEKIT_URL")
         api_key = api_key or os.getenv("LIVEKIT_API_KEY")
@@ -48,14 +50,19 @@ class LiveKitAPI:
         if not api_key or not api_secret:
             raise ValueError("api_key and api_secret must be set")
 
-        self._session = aiohttp.ClientSession(timeout=timeout)
+        self._custom_session = True
+        self._session = session
+        if not self._session:
+            self._custom_session = False
+            if not timeout:
+                timeout = aiohttp.ClientTimeout(total=60)
+            self._session = aiohttp.ClientSession(timeout=timeout)
+
         self._room = RoomService(self._session, url, api_key, api_secret)
         self._ingress = IngressService(self._session, url, api_key, api_secret)
         self._egress = EgressService(self._session, url, api_key, api_secret)
         self._sip = SipService(self._session, url, api_key, api_secret)
-        self._agent_dispatch = AgentDispatchService(
-            self._session, url, api_key, api_secret
-        )
+        self._agent_dispatch = AgentDispatchService(self._session, url, api_key, api_secret)
 
     @property
     def agent_dispatch(self) -> AgentDispatchService:
@@ -86,7 +93,9 @@ class LiveKitAPI:
         """Close the API client
 
         Call this before your application exits or when the API client is no longer needed."""
-        await self._session.close()
+        # we do not close custom sessions, that's up to the caller
+        if not self._custom_session:
+            await self._session.close()
 
     async def __aenter__(self):
         """@private

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/room_service.py

@@ -18,6 +18,8 @@ from livekit.protocol.room import (
     UpdateRoomMetadataRequest,
     RemoveParticipantResponse,
     UpdateSubscriptionsResponse,
+    ForwardParticipantRequest,
+    ForwardParticipantResponse,
 )
 from livekit.protocol.models import Room, ParticipantInfo
 from ._service import Service
@@ -41,9 +43,7 @@ class RoomService(Service):
     Also see https://docs.livekit.io/home/server/managing-rooms/ and https://docs.livekit.io/home/server/managing-participants/
     """
 
-    def __init__(
-        self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str
-    ):
+    def __init__(self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str):
         super().__init__(session, url, api_key, api_secret)
 
     async def create_room(
@@ -130,9 +130,7 @@ class RoomService(Service):
             Room,
         )
 
-    async def list_participants(
-        self, list: ListParticipantsRequest
-    ) -> ListParticipantsResponse:
+    async def list_participants(self, list: ListParticipantsRequest) -> ListParticipantsResponse:
         """Lists all participants in a room.
 
         Args:
@@ -201,6 +199,26 @@ class RoomService(Service):
             RemoveParticipantResponse,
         )
 
+    async def forward_participant(self, forward: ForwardParticipantRequest) -> None:
+        """Forwards a participant and their published tracks from one room to another.
+
+        This feature is only available for LiveKit Cloud/Private Cloud.
+
+        Args:
+            forward (ForwardParticipantRequest): arg containing:
+                - room: str - Room name
+                - identity: str - identity of Participant to forward
+                - destination_room: str - Destination room name
+        """
+        # currently nothing is returned
+        await self._client.request(
+            SVC,
+            "ForwardParticipant",
+            forward,
+            self._auth_header(VideoGrants(room_admin=True, room=forward.room)),
+            ForwardParticipantResponse,
+        )
+
     async def mute_published_track(
         self,
         update: MuteRoomTrackRequest,
@@ -226,9 +244,7 @@ class RoomService(Service):
             MuteRoomTrackResponse,
         )
 
-    async def update_participant(
-        self, update: UpdateParticipantRequest
-    ) -> ParticipantInfo:
+    async def update_participant(self, update: UpdateParticipantRequest) -> ParticipantInfo:
         """Updates a participant's metadata or permissions.
 
         Args:

livekit_api-1.0.1/livekit/api/sip_service.py

@@ -0,0 +1,447 @@
+import aiohttp
+from typing import Optional
+
+from livekit.protocol.models import ListUpdate
+from livekit.protocol.sip import (
+    SIPTrunkInfo,
+    CreateSIPInboundTrunkRequest,
+    UpdateSIPInboundTrunkRequest,
+    SIPInboundTrunkInfo,
+    SIPInboundTrunkUpdate,
+    CreateSIPOutboundTrunkRequest,
+    UpdateSIPOutboundTrunkRequest,
+    SIPOutboundTrunkInfo,
+    SIPOutboundTrunkUpdate,
+    ListSIPInboundTrunkRequest,
+    ListSIPInboundTrunkResponse,
+    ListSIPOutboundTrunkRequest,
+    ListSIPOutboundTrunkResponse,
+    DeleteSIPTrunkRequest,
+    SIPDispatchRule,
+    SIPDispatchRuleInfo,
+    SIPDispatchRuleUpdate,
+    CreateSIPDispatchRuleRequest,
+    UpdateSIPDispatchRuleRequest,
+    ListSIPDispatchRuleRequest,
+    ListSIPDispatchRuleResponse,
+    DeleteSIPDispatchRuleRequest,
+    CreateSIPParticipantRequest,
+    TransferSIPParticipantRequest,
+    SIPParticipantInfo,
+    SIPTransport,
+)
+from ._service import Service
+from .access_token import VideoGrants, SIPGrants
+
+SVC = "SIP"
+"""@private"""
+
+
+class SipService(Service):
+    """Client for LiveKit SIP Service API
+
+    Recommended way to use this service is via `livekit.api.LiveKitAPI`:
+
+    ```python
+    from livekit import api
+    lkapi = api.LiveKitAPI()
+    sip_service = lkapi.sip
+    ```
+    """
+
+    def __init__(self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str):
+        super().__init__(session, url, api_key, api_secret)
+
+    async def create_sip_inbound_trunk(
+        self, create: CreateSIPInboundTrunkRequest
+    ) -> SIPInboundTrunkInfo:
+        """Create a new SIP inbound trunk.
+
+        Args:
+            create: Request containing trunk details
+
+        Returns:
+            Created SIP inbound trunk
+        """
+        return await self._client.request(
+            SVC,
+            "CreateSIPInboundTrunk",
+            create,
+            self._admin_headers(),
+            SIPInboundTrunkInfo,
+        )
+
+    async def update_sip_inbound_trunk(
+        self,
+        trunk_id: str,
+        trunk: SIPInboundTrunkInfo,
+    ) -> SIPInboundTrunkInfo:
+        """Updates an existing SIP inbound trunk by replacing it entirely.
+
+        Args:
+            trunk_id: ID of the SIP inbound trunk to update
+            trunk: SIP inbound trunk to update with
+
+        Returns:
+            Updated SIP inbound trunk
+        """
+        return await self._client.request(
+            SVC,
+            "UpdateSIPInboundTrunk",
+            UpdateSIPInboundTrunkRequest(
+                sip_trunk_id=trunk_id,
+                replace=trunk,
+            ),
+            self._admin_headers(),
+            SIPInboundTrunkInfo,
+        )
+
+    async def update_sip_inbound_trunk_fields(
+        self,
+        trunk_id: str,
+        *,
+        numbers: Optional[list[str]] = None,
+        allowed_addresses: Optional[list[str]] = None,
+        allowed_numbers: Optional[list[str]] = None,
+        auth_username: Optional[str] = None,
+        auth_password: Optional[str] = None,
+        name: Optional[str] = None,
+        metadata: Optional[str] = None,
+    ) -> SIPInboundTrunkInfo:
+        """Updates specific fields of an existing SIP inbound trunk.
+
+        Only provided fields will be updated.
+        """
+        update = SIPInboundTrunkUpdate(
+            auth_username=auth_username,
+            auth_password=auth_password,
+            name=name,
+            metadata=metadata,
+        )
+        if numbers is not None:
+            update.numbers = ListUpdate(set=numbers)
+        if allowed_addresses is not None:
+            update.allowed_addresses = ListUpdate(set=allowed_addresses)
+        if allowed_numbers is not None:
+            update.allowed_numbers = ListUpdate(set=allowed_numbers)
+
+        return await self._client.request(
+            SVC,
+            "UpdateSIPInboundTrunk",
+            UpdateSIPInboundTrunkRequest(
+                sip_trunk_id=trunk_id,
+                update=update,
+            ),
+            self._admin_headers(),
+            SIPInboundTrunkInfo,
+        )
+
+    async def create_sip_outbound_trunk(
+        self, create: CreateSIPOutboundTrunkRequest
+    ) -> SIPOutboundTrunkInfo:
+        """Create a new SIP outbound trunk.
+
+        Args:
+            create: Request containing trunk details
+
+        Returns:
+            Created SIP outbound trunk
+        """
+        return await self._client.request(
+            SVC,
+            "CreateSIPOutboundTrunk",
+            create,
+            self._admin_headers(),
+            SIPOutboundTrunkInfo,
+        )
+
+    async def update_sip_outbound_trunk(
+        self,
+        trunk_id: str,
+        trunk: SIPOutboundTrunkInfo,
+    ) -> SIPOutboundTrunkInfo:
+        """Updates an existing SIP outbound trunk by replacing it entirely.
+
+        Args:
+            trunk_id: ID of the SIP outbound trunk to update
+            trunk: SIP outbound trunk to update with
+
+        Returns:
+            Updated SIP outbound trunk
+        """
+        return await self._client.request(
+            SVC,
+            "UpdateSIPOutboundTrunk",
+            UpdateSIPOutboundTrunkRequest(
+                sip_trunk_id=trunk_id,
+                replace=trunk,
+            ),
+            self._admin_headers(),
+            SIPOutboundTrunkInfo,
+        )
+
+    async def update_sip_outbound_trunk_fields(
+        self,
+        trunk_id: str,
+        *,
+        address: Optional[str] = None,
+        transport: Optional[SIPTransport] = None,
+        numbers: Optional[list[str]] = None,
+        auth_username: Optional[str] = None,
+        auth_password: Optional[str] = None,
+        name: Optional[str] = None,
+        metadata: Optional[str] = None,
+    ) -> SIPOutboundTrunkInfo:
+        """Updates specific fields of an existing SIP outbound trunk.
+
+        Only provided fields will be updated.
+        """
+        update = SIPOutboundTrunkUpdate(
+            address=address,
+            transport=transport,
+            auth_username=auth_username,
+            auth_password=auth_password,
+            name=name,
+            metadata=metadata,
+        )
+        if numbers is not None:
+            update.numbers = ListUpdate(set=numbers)
+        return await self._client.request(
+            SVC,
+            "UpdateSIPOutboundTrunk",
+            UpdateSIPOutboundTrunkRequest(
+                sip_trunk_id=trunk_id,
+                update=update,
+            ),
+            self._admin_headers(),
+            SIPOutboundTrunkInfo,
+        )
+
+    async def list_sip_inbound_trunk(
+        self, list: ListSIPInboundTrunkRequest
+    ) -> ListSIPInboundTrunkResponse:
+        """List SIP inbound trunks with optional filtering.
+
+        Args:
+            list: Request with optional filtering parameters
+
+        Returns:
+            Response containing list of SIP inbound trunks
+        """
+        return await self._client.request(
+            SVC,
+            "ListSIPInboundTrunk",
+            list,
+            self._admin_headers(),
+            ListSIPInboundTrunkResponse,
+        )
+
+    async def list_sip_outbound_trunk(
+        self, list: ListSIPOutboundTrunkRequest
+    ) -> ListSIPOutboundTrunkResponse:
+        """List SIP outbound trunks with optional filtering.
+
+        Args:
+            list: Request with optional filtering parameters
+
+        Returns:
+            Response containing list of SIP outbound trunks
+        """
+        return await self._client.request(
+            SVC,
+            "ListSIPOutboundTrunk",
+            list,
+            self._admin_headers(),
+            ListSIPOutboundTrunkResponse,
+        )
+
+    async def delete_sip_trunk(self, delete: DeleteSIPTrunkRequest) -> SIPTrunkInfo:
+        """Delete a SIP trunk.
+
+        Args:
+            delete: Request containing trunk ID to delete
+
+        Returns:
+            Deleted trunk information
+        """
+        return await self._client.request(
+            SVC,
+            "DeleteSIPTrunk",
+            delete,
+            self._admin_headers(),
+            SIPTrunkInfo,
+        )
+
+    async def create_sip_dispatch_rule(
+        self, create: CreateSIPDispatchRuleRequest
+    ) -> SIPDispatchRuleInfo:
+        """Create a new SIP dispatch rule.
+
+        Args:
+            create: Request containing rule details
+
+        Returns:
+            Created SIP dispatch rule
+        """
+        return await self._client.request(
+            SVC,
+            "CreateSIPDispatchRule",
+            create,
+            self._admin_headers(),
+            SIPDispatchRuleInfo,
+        )
+
+    async def update_sip_dispatch_rule(
+        self,
+        rule_id: str,
+        rule: SIPDispatchRuleInfo,
+    ) -> SIPDispatchRuleInfo:
+        """Updates an existing SIP dispatch rule by replacing it entirely.
+
+        Args:
+            rule_id: ID of the SIP dispatch rule to update
+            rule: SIP dispatch rule to update with
+
+        Returns:
+            Updated SIP dispatch rule
+        """
+        return await self._client.request(
+            SVC,
+            "UpdateSIPDispatchRule",
+            UpdateSIPDispatchRuleRequest(sip_dispatch_rule_id=rule_id, replace=rule),
+            self._admin_headers(),
+            SIPDispatchRuleInfo,
+        )
+
+    async def update_sip_dispatch_rule_fields(
+        self,
+        rule_id: str,
+        *,
+        trunk_ids: Optional[list[str]] = None,
+        rule: Optional[SIPDispatchRule] = None,
+        name: Optional[str] = None,
+        metadata: Optional[str] = None,
+        attributes: Optional[dict[str, str]] = None,
+    ) -> SIPDispatchRuleInfo:
+        """Updates specific fields of an existing SIP dispatch rule.
+
+        Only provided fields will be updated.
+        """
+        update = SIPDispatchRuleUpdate(
+            name=name, metadata=metadata, rule=rule, attributes=attributes
+        )
+        if trunk_ids is not None:
+            update.trunk_ids = ListUpdate(set=trunk_ids)
+        return await self._client.request(
+            SVC,
+            "UpdateSIPDispatchRule",
+            UpdateSIPDispatchRuleRequest(sip_dispatch_rule_id=rule_id, update=update),
+            self._admin_headers(),
+            SIPDispatchRuleInfo,
+        )
+
+    async def list_sip_dispatch_rule(
+        self, list: ListSIPDispatchRuleRequest
+    ) -> ListSIPDispatchRuleResponse:
+        """List SIP dispatch rules with optional filtering.
+
+        Args:
+            list: Request with optional filtering parameters
+
+        Returns:
+            Response containing list of SIP dispatch rules
+        """
+        return await self._client.request(
+            SVC,
+            "ListSIPDispatchRule",
+            list,
+            self._admin_headers(),
+            ListSIPDispatchRuleResponse,
+        )
+
+    async def delete_sip_dispatch_rule(
+        self, delete: DeleteSIPDispatchRuleRequest
+    ) -> SIPDispatchRuleInfo:
+        """Delete a SIP dispatch rule.
+
+        Args:
+            delete: Request containing rule ID to delete
+
+        Returns:
+            Deleted rule information
+        """
+        return await self._client.request(
+            SVC,
+            "DeleteSIPDispatchRule",
+            delete,
+            self._admin_headers(),
+            SIPDispatchRuleInfo,
+        )
+
+    async def create_sip_participant(
+        self,
+        create: CreateSIPParticipantRequest,
+        *,
+        timeout: Optional[float] = None,
+    ) -> SIPParticipantInfo:
+        """Create a new SIP participant.
+
+        Args:
+            create: Request containing participant details
+            timeout: Optional request timeout in seconds
+
+        Returns:
+            Created SIP participant
+
+        Raises:
+            SIPError: If the SIP operation fails
+        """
+        client_timeout: Optional[aiohttp.ClientTimeout] = None
+        if timeout:
+            # obay user specified timeout
+            client_timeout = aiohttp.ClientTimeout(total=timeout)
+        elif create.wait_until_answered:
+            # ensure default timeout isn't too short when using sync mode
+            if (
+                self._client._session.timeout
+                and self._client._session.timeout.total
+                and self._client._session.timeout.total < 20
+            ):
+                client_timeout = aiohttp.ClientTimeout(total=20)
+
+        return await self._client.request(
+            SVC,
+            "CreateSIPParticipant",
+            create,
+            self._auth_header(VideoGrants(), sip=SIPGrants(call=True)),
+            SIPParticipantInfo,
+            timeout=client_timeout,
+        )
+
+    async def transfer_sip_participant(
+        self, transfer: TransferSIPParticipantRequest
+    ) -> SIPParticipantInfo:
+        """Transfer a SIP participant to a different room.
+
+        Args:
+            transfer: Request containing transfer details
+
+        Returns:
+            Updated SIP participant information
+        """
+        return await self._client.request(
+            SVC,
+            "TransferSIPParticipant",
+            transfer,
+            self._auth_header(
+                VideoGrants(
+                    room_admin=True,
+                    room=transfer.room_name,
+                ),
+                sip=SIPGrants(call=True),
+            ),
+            SIPParticipantInfo,
+        )
+
+    def _admin_headers(self) -> dict[str, str]:
+        return self._auth_header(VideoGrants(), sip=SIPGrants(admin=True))

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit/api/twirp_client.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Type, TypeVar
+from typing import Dict, Type, TypeVar, Optional
 
 import aiohttp
 from google.protobuf.message import Message
@@ -22,9 +22,18 @@ DEFAULT_PREFIX = "twirp"
 
 
 class TwirpError(Exception):
-    def __init__(self, code: str, msg: str) -> None:
+    def __init__(
+        self,
+        code: str,
+        msg: str,
+        *,
+        status: int,
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> None:
         self._code = code
         self._msg = msg
+        self._status = status
+        self._metadata = metadata or {}
 
     @property
     def code(self) -> str:
@@ -34,6 +43,23 @@ class TwirpError(Exception):
     def message(self) -> str:
         return self._msg
 
+    @property
+    def status(self) -> int:
+        """HTTP status code"""
+        return self._status
+
+    @property
+    def metadata(self) -> Dict[str, str]:
+        """Twirp metadata"""
+        return self._metadata
+
+    def __str__(self) -> str:
+        result = f"TwirpError(code={self.code}, message={self.message}, status={self.status}"
+        if self.metadata:
+            result += f", metadata={self.metadata}"
+        result += ")"
+        return result
+
 
 class TwirpErrorCode:
     CANCELED = "canceled"
@@ -85,17 +111,24 @@ class TwirpClient:
         data: Message,
         headers: Dict[str, str],
         response_class: Type[T],
+        *,
+        timeout: Optional[aiohttp.ClientTimeout] = None,
     ) -> T:
         url = f"{self.host}/{self.prefix}/{self.pkg}.{service}/{method}"
         headers["Content-Type"] = "application/protobuf"
 
         serialized_data = data.SerializeToString()
         async with self._session.post(
-            url, headers=headers, data=serialized_data
+            url, headers=headers, data=serialized_data, timeout=timeout
         ) as resp:
             if resp.status == 200:
                 return response_class.FromString(await resp.read())
             else:
                 # when we have an error, Twirp always encode it in json
                 error_data = await resp.json()
-                raise TwirpError(error_data["code"], error_data["msg"])
+                raise TwirpError(
+                    error_data.get("code", "unknown"),
+                    error_data.get("msg", ""),
+                    status=resp.status,
+                    metadata=error_data.get("meta"),
+                )

livekit_api-1.0.1/livekit/api/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.1"

{livekit_api-0.8.2 → livekit_api-1.0.1}/livekit_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: livekit-api
-Version: 0.8.2
+Version: 1.0.1
 Summary: Python Server API for LiveKit
 Home-page: https://github.com/livekit/python-sdks
 License: Apache-2.0
@@ -23,9 +23,9 @@ Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: protobuf>=3
-Requires-Dist: types-protobuf<5,>=4
-Requires-Dist: livekit-protocol<2,>=0.8.2
+Requires-Dist: protobuf>=4
+Requires-Dist: types-protobuf>=4
+Requires-Dist: livekit-protocol~=1.0
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

livekit_api-1.0.1/livekit_api.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pyjwt>=2.0.0
+aiohttp>=3.9.0
+protobuf>=4
+types-protobuf>=4
+livekit-protocol~=1.0

{livekit_api-0.8.2 → livekit_api-1.0.1}/setup.py

@@ -51,9 +51,9 @@ setuptools.setup(
     install_requires=[
         "pyjwt>=2.0.0",
         "aiohttp>=3.9.0",
-        "protobuf>=3",
-        "types-protobuf>=4,<5",
-        "livekit-protocol>=0.8.2,<2",
+        "protobuf>=4",
+        "types-protobuf>=4",
+        "livekit-protocol~=1.0",
     ],
     package_data={
         "livekit.api": ["py.typed", "*.pyi", "**/*.pyi"],

{livekit_api-0.8.2 → livekit_api-1.0.1}/tests/test_access_token.py

@@ -75,11 +75,7 @@ def test_agent_config():
 
 
 def test_verify_token_invalid():
-    token = (
-        AccessToken(TEST_API_KEY, TEST_API_SECRET)
-        .with_identity("test_identity")
-        .to_jwt()
-    )
+    token = AccessToken(TEST_API_KEY, TEST_API_SECRET).with_identity("test_identity").to_jwt()
 
     token_verifier = TokenVerifier(TEST_API_KEY, "invalid_secret")
     with pytest.raises(Exception):

livekit_api-0.8.2/livekit/api/sip_service.py

@@ -1,182 +0,0 @@
-import aiohttp
-from livekit.protocol.sip import (
-    CreateSIPTrunkRequest,
-    SIPTrunkInfo,
-    CreateSIPInboundTrunkRequest,
-    SIPInboundTrunkInfo,
-    CreateSIPOutboundTrunkRequest,
-    SIPOutboundTrunkInfo,
-    ListSIPTrunkRequest,
-    ListSIPTrunkResponse,
-    ListSIPInboundTrunkRequest,
-    ListSIPInboundTrunkResponse,
-    ListSIPOutboundTrunkRequest,
-    ListSIPOutboundTrunkResponse,
-    DeleteSIPTrunkRequest,
-    SIPDispatchRuleInfo,
-    CreateSIPDispatchRuleRequest,
-    ListSIPDispatchRuleRequest,
-    ListSIPDispatchRuleResponse,
-    DeleteSIPDispatchRuleRequest,
-    CreateSIPParticipantRequest,
-    TransferSIPParticipantRequest,
-    SIPParticipantInfo,
-)
-from ._service import Service
-from .access_token import VideoGrants, SIPGrants
-
-SVC = "SIP"
-"""@private"""
-
-
-class SipService(Service):
-    """Client for LiveKit SIP Service API
-
-    Recommended way to use this service is via `livekit.api.LiveKitAPI`:
-
-    ```python
-    from livekit import api
-    lkapi = api.LiveKitAPI()
-    sip_service = lkapi.sip
-    ```
-    """
-
-    def __init__(
-        self, session: aiohttp.ClientSession, url: str, api_key: str, api_secret: str
-    ):
-        super().__init__(session, url, api_key, api_secret)
-
-    async def create_sip_trunk(self, create: CreateSIPTrunkRequest) -> SIPTrunkInfo:
-        """
-        @deprecated Use create_sip_inbound_trunk or create_sip_outbound_trunk instead
-        """
-        return await self._client.request(
-            SVC,
-            "CreateSIPTrunk",
-            create,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPTrunkInfo,
-        )
-
-    async def create_sip_inbound_trunk(
-        self, create: CreateSIPInboundTrunkRequest
-    ) -> SIPInboundTrunkInfo:
-        return await self._client.request(
-            SVC,
-            "CreateSIPInboundTrunk",
-            create,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPInboundTrunkInfo,
-        )
-
-    async def create_sip_outbound_trunk(
-        self, create: CreateSIPOutboundTrunkRequest
-    ) -> SIPOutboundTrunkInfo:
-        return await self._client.request(
-            SVC,
-            "CreateSIPOutboundTrunk",
-            create,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPOutboundTrunkInfo,
-        )
-
-    async def list_sip_trunk(self, list: ListSIPTrunkRequest) -> ListSIPTrunkResponse:
-        return await self._client.request(
-            SVC,
-            "ListSIPTrunk",
-            list,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            ListSIPTrunkResponse,
-        )
-
-    async def list_sip_inbound_trunk(
-        self, list: ListSIPInboundTrunkRequest
-    ) -> ListSIPInboundTrunkResponse:
-        return await self._client.request(
-            SVC,
-            "ListSIPInboundTrunk",
-            list,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            ListSIPInboundTrunkResponse,
-        )
-
-    async def list_sip_outbound_trunk(
-        self, list: ListSIPOutboundTrunkRequest
-    ) -> ListSIPOutboundTrunkResponse:
-        return await self._client.request(
-            SVC,
-            "ListSIPOutboundTrunk",
-            list,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            ListSIPOutboundTrunkResponse,
-        )
-
-    async def delete_sip_trunk(self, delete: DeleteSIPTrunkRequest) -> SIPTrunkInfo:
-        return await self._client.request(
-            SVC,
-            "DeleteSIPTrunk",
-            delete,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPTrunkInfo,
-        )
-
-    async def create_sip_dispatch_rule(
-        self, create: CreateSIPDispatchRuleRequest
-    ) -> SIPDispatchRuleInfo:
-        return await self._client.request(
-            SVC,
-            "CreateSIPDispatchRule",
-            create,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPDispatchRuleInfo,
-        )
-
-    async def list_sip_dispatch_rule(
-        self, list: ListSIPDispatchRuleRequest
-    ) -> ListSIPDispatchRuleResponse:
-        return await self._client.request(
-            SVC,
-            "ListSIPDispatchRule",
-            list,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            ListSIPDispatchRuleResponse,
-        )
-
-    async def delete_sip_dispatch_rule(
-        self, delete: DeleteSIPDispatchRuleRequest
-    ) -> SIPDispatchRuleInfo:
-        return await self._client.request(
-            SVC,
-            "DeleteSIPDispatchRule",
-            delete,
-            self._auth_header(VideoGrants(), sip=SIPGrants(admin=True)),
-            SIPDispatchRuleInfo,
-        )
-
-    async def create_sip_participant(
-        self, create: CreateSIPParticipantRequest
-    ) -> SIPParticipantInfo:
-        return await self._client.request(
-            SVC,
-            "CreateSIPParticipant",
-            create,
-            self._auth_header(VideoGrants(), sip=SIPGrants(call=True)),
-            SIPParticipantInfo,
-        )
-
-    async def transfer_sip_participant(
-        self, transfer: TransferSIPParticipantRequest
-    ) -> SIPParticipantInfo:
-        return await self._client.request(
-            SVC,
-            "TransferSIPParticipant",
-            transfer,
-            self._auth_header(
-                VideoGrants(
-                    room_admin=True,
-                    room=transfer.room_name,
-                ),
-                sip=SIPGrants(call=True),
-            ),
-            SIPParticipantInfo,
-        )

livekit_api-0.8.2/livekit/api/version.py

@@ -1 +0,0 @@
-__version__ = "0.8.2"

livekit_api-0.8.2/livekit_api.egg-info/requires.txt

@@ -1,5 +0,0 @@
-pyjwt>=2.0.0
-aiohttp>=3.9.0
-protobuf>=3
-types-protobuf<5,>=4
-livekit-protocol<2,>=0.8.2