webscout 8.2.9__py3-none-any.whl → 8.3__py3-none-any.whl

webscout/Provider/OPENAI/toolbaz.py

@@ -10,8 +10,8 @@ from datetime import datetime
 from typing import List, Dict, Optional, Union, Generator, Any
 
 from webscout.litagent import LitAgent
-from .base import BaseChat, BaseCompletions, OpenAICompatibleProvider
-from .utils import (
+from webscout.Provider.OPENAI.base import BaseChat, BaseCompletions, OpenAICompatibleProvider
+from webscout.Provider.OPENAI.utils import (
     ChatCompletion,
     ChatCompletionChunk,
     Choice,
@@ -40,6 +40,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -68,16 +70,18 @@ class Completions(BaseCompletions):
 
         # Handle streaming response
         if stream:
-            return self._handle_streaming_response(request_id, created_time, model, data)
+            return self._handle_streaming_response(request_id, created_time, model, data, timeout, proxies)
         else:
-            return self._handle_non_streaming_response(request_id, created_time, model, data)
+            return self._handle_non_streaming_response(request_id, created_time, model, data, timeout, proxies)
 
     def _handle_streaming_response(
         self,
         request_id: str,
         created_time: int,
         model: str,
-        data: Dict[str, Any]
+        data: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Handle streaming response from Toolbaz API"""
         try:
@@ -85,8 +89,8 @@ class Completions(BaseCompletions):
                 "https://data.toolbaz.com/writing.php",
                 data=data,
                 stream=True,
-                proxies=self._client.proxies,
-                timeout=self._client.timeout
+                proxies=proxies or getattr(self._client, "proxies", None),
+                timeout=timeout or self._client.timeout
             )
             resp.raise_for_status()
 
@@ -219,15 +223,17 @@ class Completions(BaseCompletions):
         request_id: str,
         created_time: int,
         model: str,
-        data: Dict[str, Any]
+        data: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Handle non-streaming response from Toolbaz API"""
         try:
             resp = self._client.session.post(
                 "https://data.toolbaz.com/writing.php",
                 data=data,
-                proxies=self._client.proxies,
-                timeout=self._client.timeout
+                proxies=proxies or getattr(self._client, "proxies", None),
+                timeout=timeout or self._client.timeout
             )
             resp.raise_for_status()
 

webscout/Provider/OPENAI/typefully.py

@@ -36,6 +36,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         stream: bool = False,
         temperature: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -67,16 +69,18 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_streaming(request_id, created_time, model, payload)
+            return self._create_streaming(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_streaming(request_id, created_time, model, payload)
+            return self._create_non_streaming(request_id, created_time, model, payload, timeout, proxies)
 
     def _create_streaming(
         self,
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Implementation for streaming chat completions."""
         try:
@@ -86,7 +90,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers, 
                 json=payload, 
                 stream=True, 
-                timeout=self._client.timeout,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
                 impersonate="chrome120"
             )
 
@@ -161,7 +166,9 @@ class Completions(BaseCompletions):
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
         try:
@@ -171,7 +178,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers, 
                 json=payload, 
                 stream=True, 
-                timeout=self._client.timeout,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
                 impersonate="chrome120"
             )
 
@@ -352,4 +360,3 @@ class TypefullyAI(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/typegpt.py

@@ -34,6 +34,8 @@ class Completions(BaseCompletions):
         top_p: Optional[float] = None,
         presence_penalty: Optional[float] = None,
         frequency_penalty: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -61,12 +63,12 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_non_stream(request_id, created_time, model, payload, timeout, proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = self._client.session.post(
@@ -74,7 +76,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses
@@ -209,14 +212,15 @@ class Completions(BaseCompletions):
             raise IOError(f"TypeGPT request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         try:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses

webscout/Provider/OPENAI/uncovrAI.py

@@ -38,6 +38,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -103,7 +105,9 @@ class Completions(BaseCompletions):
                 payload=payload,
                 model=model,
                 request_id=request_id,
-                created_time=created_time
+                created_time=created_time,
+                timeout=timeout,
+                proxies=proxies
             )
 
         # Handle non-streaming response
@@ -111,7 +115,9 @@ class Completions(BaseCompletions):
             payload=payload,
             model=model,
             request_id=request_id,
-            created_time=created_time
+            created_time=created_time,
+            timeout=timeout,
+            proxies=proxies
         )
 
     def _handle_streaming_response(
@@ -120,7 +126,9 @@ class Completions(BaseCompletions):
         payload: Dict[str, Any],
         model: str,
         request_id: str,
-        created_time: int
+        created_time: int,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Handle streaming response from UncovrAI API."""
         try:
@@ -128,7 +136,8 @@ class Completions(BaseCompletions):
                 self._client.url,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             ) as response:
                 if response.status_code != 200:
                     # If we get a non-200 response, try refreshing our identity once
@@ -139,7 +148,8 @@ class Completions(BaseCompletions):
                             self._client.url,
                             json=payload,
                             stream=True,
-                            timeout=self._client.timeout
+                            timeout=timeout or self._client.timeout,
+                            proxies=proxies or getattr(self._client, "proxies", None)
                         ) as retry_response:
                             if not retry_response.ok:
                                 raise IOError(
@@ -216,14 +226,17 @@ class Completions(BaseCompletions):
         payload: Dict[str, Any],
         model: str,
         request_id: str,
-        created_time: int
+        created_time: int,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Handle non-streaming response from UncovrAI API."""
         try:
             response = self._client.session.post(
                 self._client.url,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             if response.status_code != 200:
@@ -232,7 +245,8 @@ class Completions(BaseCompletions):
                     response = self._client.session.post(
                         self._client.url,
                         json=payload,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(

webscout/Provider/OPENAI/venice.py

@@ -32,6 +32,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = 0.8,
         top_p: Optional[float] = 0.9,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -73,19 +75,20 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_non_stream(request_id, created_time, model, payload, timeout, proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses
@@ -211,7 +214,7 @@ class Completions(BaseCompletions):
             raise IOError(f"Venice request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         try:
             # For non-streaming, we still use streaming internally to collect the full response
@@ -219,7 +222,8 @@ class Completions(BaseCompletions):
                 self._client.api_endpoint,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses