more generic error handling

Author: davidzhao

livekit-api/livekit/api/__init__.py

@@ -36,7 +36,6 @@
 
 from .twirp_client import TwirpError, TwirpErrorCode
 from .livekit_api import LiveKitAPI
-from .sip_service import SIPError
 from .access_token import VideoGrants, SIPGrants, AccessToken, TokenVerifier
 from .webhook import WebhookReceiver
 from .version import __version__
@@ -55,5 +54,4 @@
     "WebhookReceiver",
     "TwirpError",
     "TwirpErrorCode",
-    "SIPError",
 ]

livekit-api/livekit/api/livekit_api.py

@@ -50,11 +50,13 @@ def __init__(
         if not api_key or not api_secret:
             raise ValueError("api_key and api_secret must be set")
 
-        if not timeout:
-            timeout = aiohttp.ClientTimeout(total=60)
-
-        self._custom_session = True if session is None else False
-        self._session = session or 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)

livekit-api/livekit/api/sip_service.py

@@ -1,5 +1,4 @@
 import aiohttp
-import re
 from typing import Optional
 
 from livekit.protocol.models import ListUpdate
@@ -32,46 +31,11 @@
     SIPTransport,
 )
 from ._service import Service
-from .twirp_client import TwirpError
 from .access_token import VideoGrants, SIPGrants
 
 SVC = "SIP"
 """@private"""
 
-_sip_status_pattern = re.compile(r"sip status: (\d+) \((.*?)\)")
-
-
-class SIPError(TwirpError):
-    """Error raised by SIP service operations.
-
-    Contains SIP specific status and message information when available.
-    """
-
-    def __init__(self, code: str, msg: str, status: Optional[int] = None):
-        super().__init__(code, msg, status=status)
-        self._sip_status: Optional[int] = None
-        self._sip_message: Optional[str] = None
-
-    @classmethod
-    def from_twirp_error(cls, e: TwirpError) -> "SIPError":
-        err = cls(e.code, e.message, status=e.status)
-        # Parse SIP status and message from error message
-        sip_status_match = _sip_status_pattern.search(e.message)
-        if sip_status_match:
-            err._sip_status = int(sip_status_match.group(1))
-            err._sip_message = sip_status_match.group(2)
-        # maintain traceback from the original error
-        err.__traceback__ = e.__traceback__
-        return err
-
-    @property
-    def sip_status(self) -> Optional[int]:
-        return self._sip_status
-
-    @property
-    def sip_message(self) -> Optional[str]:
-        return self._sip_message
-
 
 class SipService(Service):
     """Client for LiveKit SIP Service API
@@ -445,17 +409,14 @@ async def create_sip_participant(
             ):
                 client_timeout = aiohttp.ClientTimeout(total=20)
 
-        try:
-            return await self._client.request(
-                SVC,
-                "CreateSIPParticipant",
-                create,
-                self._admin_headers(),
-                SIPParticipantInfo,
-                timeout=client_timeout,
-            )
-        except TwirpError as e:
-            raise SIPError.from_twirp_error(e) from None
+        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

livekit-api/livekit/api/twirp_client.py

@@ -22,10 +22,18 @@
 
 
 class TwirpError(Exception):
-    def __init__(self, code: str, msg: str, *, status: Optional[int] = None) -> None:
+    def __init__(
+        self,
+        code: str,
+        msg: str,
+        *,
+        status: Optional[int] = None,
+        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:
@@ -37,8 +45,23 @@ def message(self) -> str:
 
     @property
     def status(self) -> Optional[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}"
+        if self.status is not None:
+            result += f", status={self.status}"
+        if self.metadata:
+            result += f", metadata={self.metadata}"
+        result += ")"
+        return result
+
 
 class TwirpErrorCode:
     CANCELED = "canceled"
@@ -106,4 +129,9 @@ async def request(
                 # when we have an error, Twirp always encode it in json
                 error_data = await resp.json()
                 print(f"Error: {error_data}, headers: {resp.headers}")
-                raise TwirpError(error_data["code"], error_data["msg"], status=resp.status)
+                raise TwirpError(
+                    error_data.get("code", "unknown"),
+                    error_data.get("msg", ""),
+                    status=resp.status,
+                    metadata=error_data.get("meta"),
+                )