GPTRouter 0.3.2__tar.gz → 0.3.4__tar.gz

{GPTRouter-0.3.2 → GPTRouter-0.3.4}/GPTRouter.egg-info/PKG-INFO

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

{GPTRouter-0.3.2 → GPTRouter-0.3.4}/PKG-INFO

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

GPTRouter-0.3.4/gpt_router/client.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+from pydantic import parse_obj_as
+import logging
+import json
+import httpx
+from typing import Generator, List, Optional, Union
+
+from gpt_router.models import (
+    GPTRouterMetadata,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+    ModelGenerationRequest,
+    GenerationResponse,
+    ChunkedGenerationResponse,
+)
+from gpt_router.exceptions import (
+    GPTRouterApiTimeoutError,
+    GPTRouterBadRequestError,
+    GPTRouterStreamingError,
+    GPTRouterForbiddenError,
+    GPTRouterInternalServerError,
+    GPTRouterNotAvailableError,
+    GPTRouterTooManyRequestsError,
+    GPTRouterUnauthorizedError,
+)
+from gpt_router.constants import DEFAULT_REQUEST_TIMEOUT
+
+from tenacity import (
+    Retrying,
+    AsyncRetrying,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_fixed,
+)
+
+logger = logging.getLogger(__name__)
+
+STATUS_CODE_EXCEPTION_MAPPING = {
+    400: GPTRouterBadRequestError,
+    406: GPTRouterNotAvailableError,
+    401: GPTRouterUnauthorizedError,
+    403: GPTRouterForbiddenError,
+    429: GPTRouterTooManyRequestsError,
+    500: GPTRouterInternalServerError,
+    503: GPTRouterNotAvailableError,
+}
+
+
+class ServerError(Exception):
+    pass
+
+
+class GPTRouterClient:
+    models = None
+    request_timeout = DEFAULT_REQUEST_TIMEOUT
+
+    def __init__(
+        self,
+        base_url,
+        api_key,
+        request_timeout: int = 60,
+        stream_read_timeout: Optional[int] = None,
+        additional_metadata: Optional[GPTRouterMetadata] = None,
+    ):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.request_timeout = request_timeout
+        self.additional_metadata = additional_metadata
+        self.stream_read_timeout = (
+            request_timeout if stream_read_timeout is None else stream_read_timeout
+        )
+
+    def add_metadata_info(
+        self,
+        payload: dict,
+        model_router_metadata: Optional[GPTRouterMetadata] = None,
+    ):
+        metadata = {}
+        if self.additional_metadata:
+            metadata.update(self.additional_metadata.dict())
+        if model_router_metadata:
+            metadata.update(model_router_metadata.dict())
+
+        payload.update(
+            {
+                "metadata": metadata,
+                "tag": metadata.get("tag"),
+                "createdByUserId": metadata.get("created_by_user_id"),
+                "historyId": (
+                    str(metadata["history_id"]) if metadata.get("history_id") else None
+                ),
+            }
+        )
+
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return payload
+
+    async def _async_api_call(self, *, path: str, method: str, payload: dict):
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.request(
+                    method,
+                    url=self.base_url.rstrip("/")
+                    + ("/api" if not self.base_url.endswith("/api") else "")
+                    + path,
+                    headers={
+                        "content-type": "application/json",
+                        "ws-secret": self.api_key,
+                    },
+                    json=payload,
+                    timeout=self.request_timeout,
+                )
+                if response.status_code == 200:
+                    return response.json()
+                elif response.status_code == 202 or response.status_code == 204:
+                    return None
+                else:
+                    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 GPTRouterApiTimeoutError("Api Request timed out")
+
+    def _api_call(self, *, path: str, method: str, payload: dict):
+        try:
+            with httpx.Client() as client:
+                response = client.request(
+                    method,
+                    url=self.base_url.rstrip("/")
+                    + ("/api" if not self.base_url.endswith("/api") else "")
+                    + path,
+                    headers={
+                        "content-type": "application/json",
+                        "ws-secret": self.api_key,
+                    },
+                    json=payload,
+                    timeout=self.request_timeout,
+                )
+                if response.status_code == 200:
+                    return response.json()
+                elif response.status_code == 202 or response.status_code == 204:
+                    return None
+                else:
+                    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 GPTRouterApiTimeoutError("Api Request timed out")
+
+    async def astream_events(
+        self, *, path: str, method: str, payload: dict, retry_count: int = 1
+    ):
+        async_retrying = AsyncRetrying(
+            stop=stop_after_attempt(retry_count),
+            wait=wait_fixed(0.5),
+            retry=(
+                retry_if_exception_type(httpx.ReadTimeout)
+                | retry_if_exception_type(ServerError)
+                | retry_if_exception_type(httpx.ReadError)
+            ),
+            before_sleep=lambda retry_state: logger.warn(
+                f"Read timeout. Retrying... (Attempt {retry_state.attempt_number} of {retry_count})"
+            ),
+        )
+        attempt_number = 0
+        async for attempt in async_retrying:
+            attempt_number += 1
+
+            if attempt_number < retry_count:
+                read_timeout = self.stream_read_timeout
+            else:
+                read_timeout = self.request_timeout
+            try:
+                async with httpx.AsyncClient() as client:
+                    async with client.stream(
+                        method,
+                        url=self.base_url.rstrip("/")
+                        + ("/api" if not self.base_url.endswith("/api") else "")
+                        + path,
+                        data=json.dumps(payload),
+                        headers={
+                            "Content-type": "application/json",
+                            "ws-secret": self.api_key,
+                        },
+                        timeout=httpx.Timeout(self.request_timeout, read=read_timeout),
+                    ) as response:
+                        if response.status_code >= 500:
+                            raise ServerError("Server error")
+                        response.raise_for_status()
+                        async for line in response.aiter_lines():
+                            try:
+                                if line.strip() == "":
+                                    continue
+
+                                line_type, line_data = (
+                                    segment.strip() for segment in line.split(":", 1)
+                                )
+
+                                if line_type != "data":
+                                    continue
+
+                                data: dict = json.loads(line_data.strip())
+                                if data["event"] == "error":
+                                    raise GPTRouterStreamingError(data)
+                                yield parse_obj_as(ChunkedGenerationResponse, data)
+                            except GPTRouterStreamingError as e:
+                                raise e
+                            except Exception:
+                                continue
+
+                        return
+            except (httpx.ReadTimeout, ServerError, httpx.ReadError) as err:
+                logger.error(str(err))
+                if attempt_number == retry_count:
+                    logger.error("All retry attempts failed")
+                    raise
+            except httpx.HTTPStatusError as err:
+                raise Exception(
+                    f"HTTP Error {err.response.status_code}: {err.response.text}"
+                ) from err
+            except httpx.TimeoutException as err:
+                raise TimeoutError("Request timed out") from err
+
+    def stream_events(
+        self, *, path: str, method: str, payload: dict, retry_count: int = 1
+    ) -> Generator[ChunkedGenerationResponse]:
+        retrying = Retrying(
+            stop=stop_after_attempt(retry_count),
+            wait=wait_fixed(0.5),
+            retry=(
+                retry_if_exception_type(httpx.ReadTimeout)
+                | retry_if_exception_type(ServerError)
+                | retry_if_exception_type(httpx.ReadError)
+            ),
+            before_sleep=lambda retry_state: logger.warn(
+                f"Read timeout. Retrying... (Attempt {retry_state.attempt_number} of {retry_count})"
+            ),
+        )
+
+        attempt_number = 0
+        for attempt in retrying:
+            attempt_number += 1
+
+            if attempt_number < retry_count:
+                read_timeout = self.stream_read_timeout
+            else:
+                read_timeout = self.request_timeout
+
+            try:
+                with httpx.Client() as client:
+                    with client.stream(
+                        method=method,
+                        url=self.base_url.rstrip("/")
+                        + ("/api" if not self.base_url.endswith("/api") else "")
+                        + path,
+                        data=json.dumps(payload),
+                        headers={
+                            "Content-type": "application/json",
+                            "ws-secret": self.api_key,
+                        },
+                        timeout=httpx.Timeout(self.request_timeout, read=read_timeout),
+                    ) as response:
+                        if response.status_code >= 500:
+                            raise ServerError("Server error")
+                        response.raise_for_status()
+                        for line in response.iter_lines():
+                            try:
+                                if line.strip() == "":
+                                    continue
+
+                                line_type, line_data = (
+                                    segment.strip() for segment in line.split(":", 1)
+                                )
+                                if line_type != "data":
+                                    continue
+
+                                data = json.loads(line_data.strip())
+                                if data["event"].lower() == "error":
+                                    raise GPTRouterStreamingError(data["message"])
+                                yield parse_obj_as(ChunkedGenerationResponse, data)
+                            except GPTRouterStreamingError as e:
+                                raise e
+                            except Exception:
+                                continue
+                        return
+            except (httpx.ReadTimeout, ServerError, httpx.ReadError) as err:
+                logger.error(str(err))
+                if attempt_number == retry_count:
+                    logger.error("All retry attempts failed")
+                    raise
+            except httpx.HTTPStatusError as err:
+                raise Exception(
+                    f"HTTP Error {err.response.status_code}: {err.response.text}"
+                ) from err
+            except httpx.TimeoutException as err:
+                raise TimeoutError("Request timed out") from err
+
+    def generate(
+        self,
+        *,
+        ordered_generation_requests: List[ModelGenerationRequest],
+        is_stream=False,
+        model_router_metadata: Optional[GPTRouterMetadata] = None,
+        **kwargs,
+    ) -> Union[GenerationResponse, Generator[ChunkedGenerationResponse]]:
+        api_path = "/v1/generate"
+        api_method = "POST"
+        api_payload = {
+            "stream": is_stream,
+            "data": [
+                request.dict(exclude_none=True, by_alias=True)
+                for request in ordered_generation_requests
+            ],
+        }
+        api_payload = self.add_metadata_info(api_payload, model_router_metadata)
+        if is_stream:
+            return self.stream_events(
+                path=api_path,
+                method=api_method,
+                payload=api_payload,
+            )
+        result = self._api_call(
+            path=api_path,
+            method=api_method,
+            payload=api_payload,
+        )
+        return parse_obj_as(GenerationResponse, result)
+
+    async def agenerate(
+        self,
+        *,
+        ordered_generation_requests: List[ModelGenerationRequest],
+        is_stream=False,
+        model_router_metadata: Optional[GPTRouterMetadata] = None,
+        **kwargs,
+    ) -> GenerationResponse:
+        api_path = "/v1/generate"
+        api_method = "POST"
+        api_payload = {
+            "stream": is_stream,
+            "data": [
+                request.dict(exclude_none=True, by_alias=True)
+                for request in ordered_generation_requests
+            ],
+        }
+        api_payload = self.add_metadata_info(api_payload, model_router_metadata)
+        if is_stream:
+            return self.astream_events(
+                path=api_path,
+                method=api_method,
+                payload=api_payload,
+            )
+        result = await self._async_api_call(
+            path=api_path,
+            method=api_method,
+            payload=api_payload,
+        )
+        return parse_obj_as(GenerationResponse, result)
+
+    async def agenerate_images(
+        self, *, image_generation_request: ImageGenerationRequest
+    ) -> List[ImageGenerationResponse]:
+        api_path = "/v1/generate/generate-image"
+        api_method = "POST"
+        api_payload = image_generation_request.dict()
+
+        api_response = await self._async_api_call(
+            path=api_path,
+            method=api_method,
+            payload=api_payload,
+        )
+        generated_images = api_response.get("response", [])
+        if isinstance(generated_images, dict):
+            generated_images = generated_images.get("artifacts", [])
+
+        return [
+            parse_obj_as(ImageGenerationResponse, generated_img)
+            for generated_img in generated_images
+        ]

{GPTRouter-0.3.2 → GPTRouter-0.3.4}/gpt_router/models.py

@@ -33,6 +33,7 @@ class GenerationParams(BaseModel):
     user_id: Optional[str] = None
     history_id: Optional[str] = None
     metadata: Optional[dict] = None
+    raw_event: Optional[bool] = None
 
 
 class ModelGenerationRequest(BaseModel):
@@ -78,6 +79,7 @@ class GenerationResponse(BaseModel):
 class ChunkedGenerationResponse(BaseModel):
     event: str
     data: dict
+    provider: Optional[str] = None
 
 
 class ImageGenerationRequest(BaseModel):

{GPTRouter-0.3.2 → GPTRouter-0.3.4}/pyproject.toml

@@ -11,6 +11,7 @@ httpx = "^0.25.2"
 pydantic = "^1.10.14"
 pyhumps = "^3.8.0"
 python-dotenv = "^1.0.0"
+tenacity = "^9.0.0"
 
 
 [build-system]

{GPTRouter-0.3.2 → GPTRouter-0.3.4}/setup.py

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

GPTRouter-0.3.2/gpt_router/client.py

@@ -1,282 +0,0 @@
-from __future__ import annotations
-from pydantic import parse_obj_as
-import logging
-import json
-import httpx
-from typing import Generator, List, Optional, Union
-
-from gpt_router.models import (
-    GPTRouterMetadata,
-    ImageGenerationRequest,
-    ImageGenerationResponse,
-    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
-    request_timeout = DEFAULT_REQUEST_TIMEOUT
-
-    def __init__(self, base_url, api_key, request_timeout: int = 60, additional_metadata: Optional[GPTRouterMetadata] = None):
-        self.base_url = base_url
-        self.api_key = api_key
-        self.request_timeout = request_timeout
-        self.additional_metadata = additional_metadata
-
-    def add_metadata_info(
-        self,
-        payload: dict,
-        model_router_metadata: Optional[GPTRouterMetadata] = None,
-    ):
-        metadata = {}
-        if self.additional_metadata:
-            metadata.update(self.additional_metadata.dict())
-        if model_router_metadata:
-            metadata.update(model_router_metadata.dict())
-
-        payload.update(
-            {
-                "metadata": metadata,
-                "tag": metadata.get('tag'),
-                "createdByUserId": metadata['created_by_user_id'],
-                "historyId": str(metadata['history_id']) if metadata.get('history_id') else None,
-            }
-        )
-
-        payload = {k: v for k, v in payload.items() if v is not None}
-        return payload
-
-    async def _async_api_call(self, *, path: str, method: str, payload: dict):
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.request(
-                    method,
-                    url=self.base_url.rstrip('/') + ('/api' if not self.base_url.endswith('/api') else '') + path,
-                    headers={
-                        "content-type": "application/json",
-                        "ws-secret": self.api_key,
-                    },
-                    json=payload,
-                    timeout=self.request_timeout,
-                )
-                if response.status_code == 200:
-                    return response.json()
-                elif response.status_code == 202 or response.status_code == 204:
-                    return None
-                else:
-                    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 GPTRouterApiTimeoutError("Api Request timed out")
-
-    def _api_call(self, *, path: str, method: str, payload: dict):
-        try:
-            with httpx.Client() as client:
-                response = client.request(
-                    method,
-                    url=self.base_url.rstrip('/') + ('/api' if not self.base_url.endswith('/api') else '') + path,
-                    headers={
-                        "content-type": "application/json",
-                        "ws-secret": self.api_key,
-                    },
-                    json=payload,
-                    timeout=self.request_timeout,
-                )
-                if response.status_code == 200:
-                    return response.json()
-                elif response.status_code == 202 or response.status_code == 204:
-                    return None
-                else:
-                    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 GPTRouterApiTimeoutError("Api Request timed out")
-
-    async def astream_events(self, *, path: str, method: str, payload: dict):
-        try:
-            async with httpx.AsyncClient() as client:
-                async with client.stream(
-                    method,
-                    url=self.base_url.rstrip('/') + ('/api' if not self.base_url.endswith('/api') else '') + path,
-                    data=json.dumps(payload),
-                    headers={
-                        "Content-type": "application/json",
-                        "ws-secret": self.api_key,
-                    },
-                    timeout=self.request_timeout,
-                ) as response:
-                    async for line in response.aiter_lines():
-                        try:
-                            if line.strip() == "":
-                                continue
-
-                            line_type, line_data = (
-                                segment.strip() for segment in line.split(":", 1)
-                            )
-
-                            if line_type != "data":
-                                continue
-
-                            data: dict = json.loads(line_data.strip())
-                            if data["event"] == "error":
-                                raise GPTRouterStreamingError(data)
-                            yield parse_obj_as(ChunkedGenerationResponse, 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]:
-        try:
-            with httpx.Client() as client:
-                with client.stream(
-                    method=method,
-                    url=self.base_url.rstrip('/') + ('/api' if not self.base_url.endswith('/api') else '') + path,
-                    data=json.dumps(payload),
-                    headers={
-                        "Content-type": "application/json",
-                        "ws-secret": self.api_key,
-                    },
-                    timeout=self.request_timeout,
-                ) as response:
-                    for line in response.iter_lines():
-                        try:
-                            if line.strip() == "":
-                                continue
-
-                            line_type, line_data = (
-                                segment.strip() for segment in line.split(":", 1)
-                            )
-                            if line_type != "data":
-                                continue
-
-                            data = json.loads(line_data.strip())
-                            if data["event"].lower() == "error":
-                                raise GPTRouterStreamingError(data["message"])
-                            yield parse_obj_as(ChunkedGenerationResponse, 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,
-        model_router_metadata: Optional[GPTRouterMetadata] = None,
-        **kwargs,
-    ) -> Union[GenerationResponse, Generator[ChunkedGenerationResponse]]:
-        api_path = "/v1/generate"
-        api_method = "POST"
-        api_payload = {
-            "stream": is_stream,
-            "data": [
-                request.dict(exclude_none=True, by_alias=True)
-                for request in ordered_generation_requests
-            ],
-        }
-        api_payload = self.add_metadata_info(api_payload, model_router_metadata)
-        if is_stream:
-            return self.stream_events(
-                path=api_path,
-                method=api_method,
-                payload=api_payload,
-            )
-        result = self._api_call(
-            path=api_path,
-            method=api_method,
-            payload=api_payload,
-        )
-        return parse_obj_as(GenerationResponse, result)
-
-    async def agenerate(
-        self,
-        *,
-        ordered_generation_requests: List[ModelGenerationRequest],
-        is_stream=False,
-        model_router_metadata: Optional[GPTRouterMetadata] = None,
-        **kwargs,
-    ) -> GenerationResponse:
-        api_path = "/v1/generate"
-        api_method = "POST"
-        api_payload = {
-            "stream": is_stream,
-            "data": [
-                request.dict(exclude_none=True, by_alias=True)
-                for request in ordered_generation_requests
-            ],
-        }
-        api_payload = self.add_metadata_info(api_payload, model_router_metadata)
-        if is_stream:
-            return self.astream_events(
-                path=api_path,
-                method=api_method,
-                payload=api_payload,
-            )
-        result = await self._async_api_call(
-            path=api_path,
-            method=api_method,
-            payload=api_payload,
-        )
-        return parse_obj_as(GenerationResponse, result)
-
-    async def agenerate_images(
-        self, *, image_generation_request: ImageGenerationRequest
-    ) -> List[ImageGenerationResponse]:
-        api_path = "/v1/generate/generate-image"
-        api_method = "POST"
-        api_payload = image_generation_request.dict()
-
-        api_response = await self._async_api_call(
-            path=api_path,
-            method=api_method,
-            payload=api_payload,
-        )
-        generated_images = api_response.get("response", [])
-        if isinstance(generated_images, dict):
-            generated_images = generated_images.get("artifacts", [])
-
-        return [
-            parse_obj_as(ImageGenerationResponse, generated_img)
-            for generated_img in generated_images
-        ]