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

webscout/Provider/OPENAI/copilot.py

@@ -33,6 +33,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -49,17 +51,24 @@ class Completions(BaseCompletions):
         image = kwargs.get("image")
 
         if stream:
-            return self._create_stream(request_id, created_time, model, formatted_prompt, image)
+            return self._create_stream(request_id, created_time, model, formatted_prompt, image, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, formatted_prompt, image)
+            return self._create_non_stream(request_id, created_time, model, formatted_prompt, image, timeout=timeout, proxies=proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, prompt_text: str, image: Optional[bytes] = None
+        self, request_id: str, created_time: int, model: str, prompt_text: str, image: Optional[bytes] = None,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
+            timeout_val = timeout if timeout is not None else self._client.timeout
             s = self._client.session
             # Create a new conversation if needed
-            r = s.post(self._client.conversation_url)
+            r = s.post(self._client.conversation_url, timeout=timeout_val)
             if r.status_code != 200:
                 raise RuntimeError(f"Failed to create conversation: {r.text}")
             conv_id = r.json().get("id")
@@ -70,13 +79,15 @@ class Completions(BaseCompletions):
                 r = s.post(
                     f"{self._client.url}/c/api/attachments",
                     headers={"content-type": "image/jpeg"},
-                    data=image
+                    data=image,
+                    timeout=timeout_val
                 )
                 if r.status_code != 200:
                     raise RuntimeError(f"Image upload failed: {r.text}")
                 images.append({"type": "image", "url": r.json().get("url")})
 
             # Connect to websocket
+            # Note: ws_connect might not use timeout in the same way as POST/GET
             ws = s.ws_connect(self._client.websocket_url)
 
             # Use model to set mode ("reasoning" for Think Deeper)
@@ -165,12 +176,16 @@ class Completions(BaseCompletions):
 
         except Exception as e:
             raise RuntimeError(f"Stream error: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, prompt_text: str, image: Optional[bytes] = None
+        self, request_id: str, created_time: int, model: str, prompt_text: str, image: Optional[bytes] = None,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> ChatCompletion:
         result = ""
-        for chunk in self._create_stream(request_id, created_time, model, prompt_text, image):
+        # Pass timeout and proxies to the underlying _create_stream call
+        for chunk in self._create_stream(request_id, created_time, model, prompt_text, image, timeout=timeout, proxies=proxies):
             if hasattr(chunk, 'choices') and chunk.choices and hasattr(chunk.choices[0], 'delta') and chunk.choices[0].delta.content:
                 result += chunk.choices[0].delta.content
 
@@ -222,9 +237,10 @@ class Copilot(OpenAICompatibleProvider):
     
     AVAILABLE_MODELS = ["Copilot", "Think Deeper"]
 
-    def __init__(self, timeout: int = 900, browser: str = "chrome", tools: Optional[List] = None, **kwargs):
-        self.timeout = timeout
-        self.session = Session(timeout=timeout, impersonate=browser)
+    def __init__(self, browser: str = "chrome", tools: Optional[List] = None, **kwargs):
+        self.timeout = 900
+        self.session = Session(impersonate=browser)
+        self.session.proxies = {}
 
         # Initialize tools
         self.available_tools = {}

webscout/Provider/OPENAI/deepinfra.py

@@ -5,8 +5,8 @@ import uuid
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage
 )
@@ -32,6 +32,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]]:
         """
@@ -55,12 +57,13 @@ 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(
@@ -68,7 +71,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
             )
             response.raise_for_status()
 
@@ -168,14 +172,16 @@ class Completions(BaseCompletions):
             raise
 
     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.base_url,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
             )
             response.raise_for_status()
             data = response.json()
@@ -227,7 +233,7 @@ class DeepInfra(OpenAICompatibleProvider):
     
     AVAILABLE_MODELS = [
         # "anthropic/claude-3-7-sonnet-latest",  # >>>> NOT WORKING
-
+        "deepseek-ai/DeepSeek-R1-0528",
         "deepseek-ai/DeepSeek-R1",
         "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
@@ -284,8 +290,8 @@ class DeepInfra(OpenAICompatibleProvider):
         # "Sao10K/L3.3-70B-Euryale-v2.3",  # >>>> NOT WORKING
     ]
 
-    def __init__(self, timeout: Optional[int] = None, browser: str = "chrome"):
-        self.timeout = timeout
+    def __init__(self, browser: str = "chrome"):
+        self.timeout = None # Default timeout
         self.base_url = "https://api.deepinfra.com/v1/openai/chat/completions"
         self.session = requests.Session()
 
@@ -319,4 +325,15 @@ class DeepInfra(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()
+    
+if __name__ == "__main__":
+    # Example usage
+    client = DeepInfra()
+    response = client.chat.completions.create(
+        model="deepseek-ai/DeepSeek-R1-0528",
+        messages=[{"role": "user", "content": "Hello, how are you?"}],
+        max_tokens=100,
+        stream=False
+    )
+    print(response)