GPTRouter 0.1.2__tar.gz → 0.1.3__tar.gz

{GPTRouter-0.1.2 → GPTRouter-0.1.3}/GPTRouter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GPTRouter
-Version: 0.1.2
+Version: 0.1.3
 Summary: A Python package for working with GPTRouter APIs
 Author-email: sirjanpreet.ext@writesonic.com
 Classifier: Development Status :: 3 - Alpha

{GPTRouter-0.1.2 → GPTRouter-0.1.3}/GPTRouter.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ gpt_router/__init__.py
 gpt_router/client.py
 gpt_router/constants.py
 gpt_router/enums.py
+gpt_router/exceptions.py
 gpt_router/models.py

{GPTRouter-0.1.2 → GPTRouter-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GPTRouter
-Version: 0.1.2
+Version: 0.1.3
 Summary: A Python package for working with GPTRouter APIs
 Author-email: sirjanpreet.ext@writesonic.com
 Classifier: Development Status :: 3 - Alpha

{GPTRouter-0.1.2 → GPTRouter-0.1.3}/gpt_router/client.py

@@ -5,11 +5,35 @@ import json
 import httpx
 from typing import Generator, List, Union
 
-from gpt_router.models import ModelGenerationRequest, GenerationResponse, ChunkedGenerationResponse
+from gpt_router.models import (
+    ModelGenerationRequest,
+    GenerationResponse,
+    ChunkedGenerationResponse,
+)
+from gpt_router.exceptions import (
+    GPTRouterApiTimeoutError,
+    GPTRouterBadRequestError,
+    GPTRouterStreamingError,
+    GPTRouterForbiddenError,
+    GPTRouterInternalServerError,
+    GPTRouterNotAvailableError,
+    GPTRouterTooManyRequestsError,
+    GPTRouterUnauthorizedError,
+)
 from gpt_router.constants import DEFAULT_REQUEST_TIMEOUT
 
 logger = logging.getLogger(__name__)
 
+STATUS_CODE_EXCEPTION_MAPPING = {
+    400: GPTRouterBadRequestError,
+    406: GPTRouterNotAvailableError,
+    401: GPTRouterUnauthorizedError,
+    403: GPTRouterForbiddenError,
+    429: GPTRouterTooManyRequestsError,
+    500: GPTRouterInternalServerError,
+    503: GPTRouterNotAvailableError,
+}
+
 
 class GPTRouterClient:
     models = None
@@ -35,17 +59,17 @@ class GPTRouterClient:
                 )
                 if response.status_code == 200:
                     return response.json()
-                elif (
-                    response.status_code == 202
-                    or response.status_code == 204
-                ):
+                elif response.status_code == 202 or response.status_code == 204:
                     return None
                 else:
-                    raise Exception(response.json())
+                    error_class = STATUS_CODE_EXCEPTION_MAPPING.get(
+                        response.status_code, Exception
+                    )
+                    raise error_class(response.json())
         except httpx.TimeoutException as err:
             logger.error(f"Timeout error: {err}")
-            raise TimeoutError("Request timed out")
-        
+            raise GPTRouterApiTimeoutError("Api Request timed out")
+
     def _api_call(self, *, path: str, method: str, payload: dict):
         try:
             with httpx.Client() as client:
@@ -61,16 +85,16 @@ class GPTRouterClient:
                 )
                 if response.status_code == 200:
                     return response.json()
-                elif (
-                    response.status_code == 202
-                    or response.status_code == 204
-                ):
+                elif response.status_code == 202 or response.status_code == 204:
                     return None
                 else:
-                    raise Exception(response.json())
+                    error_class = STATUS_CODE_EXCEPTION_MAPPING.get(
+                        response.status_code, Exception
+                    )
+                    raise error_class(response.json())
         except httpx.TimeoutException as err:
             logger.error(f"Timeout error: {err}")
-            raise TimeoutError("Request timed out")
+            raise GPTRouterApiTimeoutError("Api Request timed out")
 
     async def astream_events(self, *, path: str, method: str, payload: dict):
         try:
@@ -79,7 +103,10 @@ class GPTRouterClient:
                     method,
                     url=f"{self.base_url}/api{path}",
                     data=json.dumps(payload),
-                    headers={"Content-type": "application/json", "ws-secret": self.api_key},
+                    headers={
+                        "Content-type": "application/json",
+                        "ws-secret": self.api_key,
+                    },
                     timeout=self.request_timeout,
                 ) as response:
                     async for line in response.aiter_lines():
@@ -95,22 +122,30 @@ class GPTRouterClient:
                                 continue
 
                             data: dict = json.loads(line_data.strip())
-
+                            if data["event"] == "error":
+                                raise GPTRouterStreamingError(data)
                             yield ChunkedGenerationResponse.model_validate(data)
+                        except GPTRouterStreamingError as e:
+                            raise e
                         except Exception:
                             continue
         except httpx.TimeoutException as err:
             logger.error(f"Timeout error: {err}")
             raise TimeoutError("Request timed out")
 
-    def stream_events(self, *, path: str, method: str, payload: dict) -> Generator[ChunkedGenerationResponse]:
+    def stream_events(
+        self, *, path: str, method: str, payload: dict
+    ) -> Generator[ChunkedGenerationResponse]:
         try:
             with httpx.Client() as client:
                 with client.stream(
                     method=method,
                     url=f"{self.base_url}/api{path}",
                     data=json.dumps(payload),
-                    headers={"Content-type": "application/json", "ws-secret": self.api_key},
+                    headers={
+                        "Content-type": "application/json",
+                        "ws-secret": self.api_key,
+                    },
                     timeout=self.request_timeout,
                 ) as response:
                     for line in response.iter_lines():
@@ -125,19 +160,31 @@ class GPTRouterClient:
                                 continue
 
                             data = json.loads(line_data.strip())
+                            if data["event"].lower() == "error":
+                                raise GPTRouterStreamingError(data["message"])
                             yield ChunkedGenerationResponse.model_validate(data)
+                        except GPTRouterStreamingError as e:
+                            raise e
                         except Exception:
                             continue
         except httpx.TimeoutException as err:
             logger.error(f"Timeout error: {err}")
             raise TimeoutError("Request timed out")
 
-    def generate(self, *, ordered_generation_requests: List[ModelGenerationRequest], is_stream=False) -> Union[GenerationResponse, Generator[ChunkedGenerationResponse]]:
+    def generate(
+        self,
+        *,
+        ordered_generation_requests: List[ModelGenerationRequest],
+        is_stream=False,
+    ) -> Union[GenerationResponse, Generator[ChunkedGenerationResponse]]:
         api_path = "/v1/generate"
         api_method = "POST"
         api_payload = {
             "stream": is_stream,
-            "data":  [request.model_dump(exclude_none=True, by_alias=True) for request in ordered_generation_requests],
+            "data": [
+                request.model_dump(exclude_none=True, by_alias=True)
+                for request in ordered_generation_requests
+            ],
         }
         if is_stream:
             return self.stream_events(
@@ -145,18 +192,28 @@ class GPTRouterClient:
                 method=api_method,
                 payload=api_payload,
             )
-        return GenerationResponse.model_validate(self._api_call(
-            path=api_path,
-            method=api_method,
-            payload=api_payload,
-        ))
-    
-    async def agenerate(self, *, ordered_generation_requests: List[ModelGenerationRequest], is_stream=False) -> GenerationResponse:
+        return GenerationResponse.model_validate(
+            self._api_call(
+                path=api_path,
+                method=api_method,
+                payload=api_payload,
+            )
+        )
+
+    async def agenerate(
+        self,
+        *,
+        ordered_generation_requests: List[ModelGenerationRequest],
+        is_stream=False,
+    ) -> GenerationResponse:
         api_path = "/v1/generate"
         api_method = "POST"
         api_payload = {
             "stream": is_stream,
-            "data":  [request.model_dump(exclude_none=True, by_alias=True) for request in ordered_generation_requests],
+            "data": [
+                request.model_dump(exclude_none=True, by_alias=True)
+                for request in ordered_generation_requests
+            ],
         }
         if is_stream:
             return self.astream_events(
@@ -164,8 +221,10 @@ class GPTRouterClient:
                 method=api_method,
                 payload=api_payload,
             )
-        return GenerationResponse.model_validate(await self._async_api_call(
-            path=api_path,
-            method=api_method,
-            payload=api_payload,
-        ))
+        return GenerationResponse.model_validate(
+            await self._async_api_call(
+                path=api_path,
+                method=api_method,
+                payload=api_payload,
+            )
+        )

GPTRouter-0.1.3/gpt_router/exceptions.py

@@ -0,0 +1,59 @@
+class GPTRouterBadRequestError(Exception):
+    """Exception raised for HTTP status code 400: Bad Request within the GPTRouter.
+
+    This status code indicates that the GPTRouter could not understand the request due to invalid syntax."""
+
+    pass
+
+
+class GPTRouterNotAvailableError(Exception):
+    """Exception raised when GPTRouter is unavailable"""
+
+    pass
+
+
+class GPTRouterUnauthorizedError(Exception):
+    """Exception raised for HTTP status code 401: Unauthorized.
+
+    This status code indicates that the client must authenticate itself with the correct GPTRouter API Token."""
+
+    pass
+
+
+class GPTRouterForbiddenError(Exception):
+    """Exception raised for HTTP status code 403: Forbidden.
+
+    This status code indicates that the client does not have privileges to perform an action on GPTRouter."""
+
+    pass
+
+
+class GPTRouterInternalServerError(Exception):
+    """Exception raised for HTTP status code 500: Internal Server Error within the GPTRouter.
+
+    This status code indicates a server error at GPTRouter end, as the name suggests."""
+
+    pass
+
+
+class GPTRouterTooManyRequestsError(Exception):
+    """Exception raised for status code 429: Too Many Requests.
+
+    This status code indicates that the user has sent too many requests in a given amount of time."""
+
+    def __init__(self, message="You are being rate limited"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class GPTRouterApiTimeoutError(Exception):
+    """Exception raised for API request timeout within the GPTRouter.
+    Indicates that the request took too long to complete."""
+
+    pass
+
+
+class GPTRouterStreamingError(Exception):
+    """Exception raised for Errors received during streaming a generation response"""
+
+    pass

{GPTRouter-0.1.2 → GPTRouter-0.1.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='GPTRouter',
-    version='0.1.2',
+    version='0.1.3',
     description='A Python package for working with GPTRouter APIs',
     long_description=long_description,
     long_description_content_type="text/markdown",