webscout 8.2.4__py3-none-any.whl → 8.2.5__py3-none-any.whl

webscout/Provider/Deepinfra.py

@@ -2,11 +2,11 @@ from curl_cffi.requests import Session
 from curl_cffi import CurlError
 import json
 import os
-from typing import Any, Dict, Optional, Generator, Union
+from typing import Any, Dict, Optional, Generator, Union, List
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider, AsyncProvider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -73,6 +73,13 @@ class DeepInfra(Provider):
         # "Sao10K/L3.3-70B-Euryale-v2.3",  # >>>> NOT WORKING
     ]
 
+    @staticmethod
+    def _deepinfra_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from DeepInfra stream JSON objects."""
+        if isinstance(chunk, dict):
+            return chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+        return None
+
     def __init__(
         self,
         is_conversation: bool = True,
@@ -91,14 +98,14 @@ class DeepInfra(Provider):
         """Initializes the DeepInfra API client."""
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-            
+
         self.url = "https://api.deepinfra.com/v1/openai/chat/completions"
-        
+
         # Initialize LitAgent (keep if needed for other headers or logic)
         self.agent = LitAgent()
         # Fingerprint generation might be less relevant with impersonate
         self.fingerprint = self.agent.generate_fingerprint(browser)
-        
+
         # Use the fingerprint for headers (keep relevant ones)
         self.headers = {
             "Accept": self.fingerprint["accept"], # Keep Accept
@@ -113,7 +120,7 @@ class DeepInfra(Provider):
             "Sec-Fetch-Site": "same-site",
             "X-Deepinfra-Source": "web-embed", # Keep custom headers
         }
-        
+
         # Initialize curl_cffi Session
         self.session = Session()
         # Update curl_cffi session headers and proxies
@@ -147,22 +154,22 @@ class DeepInfra(Provider):
     def refresh_identity(self, browser: str = None):
         """
         Refreshes the browser identity fingerprint.
-        
+
         Args:
             browser: Specific browser to use for the new fingerprint
         """
         browser = browser or self.fingerprint.get("browser_type", "chrome")
         self.fingerprint = self.agent.generate_fingerprint(browser)
-        
+
         # Update headers with new fingerprint (only relevant ones)
         self.headers.update({
             "Accept": self.fingerprint["accept"],
             "Accept-Language": self.fingerprint["accept_language"],
         })
-        
+
         # Update session headers
         self.session.headers.update(self.headers) # Update only relevant headers
-        
+
         return self.fingerprint
 
     def ask(
@@ -197,68 +204,74 @@ class DeepInfra(Provider):
             try:
                 # Use curl_cffi session post with impersonate
                 response = self.session.post(
-                    self.url, 
+                    self.url,
                     # headers are set on the session
-                    data=json.dumps(payload), 
-                    stream=True, 
+                    data=json.dumps(payload),
+                    stream=True,
                     timeout=self.timeout,
                     impersonate="chrome110" # Use a common impersonation profile
                 )
                 response.raise_for_status() # Check for HTTP errors
-                    
-                # Iterate over bytes and decode manually
-                for line_bytes in response.iter_lines():
-                    if line_bytes:
-                        try:
-                            line = line_bytes.decode('utf-8').strip()
-                            if line.startswith("data: "):
-                                json_str = line[6:]
-                                if json_str == "[DONE]":
-                                    break
-                                json_data = json.loads(json_str)
-                                if 'choices' in json_data:
-                                    choice = json_data['choices'][0]
-                                    if 'delta' in choice and 'content' in choice['delta']:
-                                        content = choice['delta']['content']
-                                        if content: # Ensure content is not None or empty
-                                            streaming_text += content
-                                            resp = dict(text=content)
-                                            # Yield dict or raw string chunk
-                                            yield resp if not raw else content
-                        except (json.JSONDecodeError, UnicodeDecodeError):
-                            continue # Ignore lines that are not valid JSON or cannot be decoded
-                    
-                # Update history after stream finishes
-                self.last_response = {"text": streaming_text}
-                self.conversation.update_chat_history(prompt, streaming_text)
-                    
-            except CurlError as e: # Catch CurlError
+
+                # Use sanitize_stream
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value="data:",
+                    to_json=True,     # Stream sends JSON
+                    skip_markers=["[DONE]"],
+                    content_extractor=self._deepinfra_extractor, # Use the specific extractor
+                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                )
+
+                for content_chunk in processed_stream:
+                    # content_chunk is the string extracted by _deepinfra_extractor
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        resp = dict(text=content_chunk)
+                        yield resp if not raw else content_chunk
+
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
-            except Exception as e: # Catch other potential exceptions (like HTTPError)
-                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
-                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {str(e)} - {err_text}") from e
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {str(e)}") from e
+            finally:
+                # Update history after stream finishes or fails
+                if streaming_text:
+                    self.last_response = {"text": streaming_text}
+                    self.conversation.update_chat_history(prompt, streaming_text)
 
 
         def for_non_stream():
             try:
                 # Use curl_cffi session post with impersonate for non-streaming
                 response = self.session.post(
-                    self.url, 
+                    self.url,
                     # headers are set on the session
-                    data=json.dumps(payload), 
+                    data=json.dumps(payload),
                     timeout=self.timeout,
                     impersonate="chrome110" # Use a common impersonation profile
                 )
                 response.raise_for_status() # Check for HTTP errors
 
-                response_data = response.json()
-                if 'choices' in response_data and len(response_data['choices']) > 0:
-                    content = response_data['choices'][0].get('message', {}).get('content', '')
-                    self.last_response = {"text": content}
-                    self.conversation.update_chat_history(prompt, content)
-                    return self.last_response if not raw else content # Return dict or raw string
-                else:
-                    raise exceptions.FailedToGenerateResponseError("No response content found")
+                response_text = response.text # Get raw text
+
+                # Use sanitize_stream to parse the non-streaming JSON response
+                processed_stream = sanitize_stream(
+                    data=response_text,
+                    to_json=True, # Parse the whole text as JSON
+                    intro_value=None,
+                    # Extractor for non-stream structure
+                    content_extractor=lambda chunk: chunk.get("choices", [{}])[0].get("message", {}).get("content") if isinstance(chunk, dict) else None,
+                    yield_raw_on_error=False
+                )
+                # Extract the single result
+                content = next(processed_stream, None)
+                content = content if isinstance(content, str) else "" # Ensure it's a string
+
+                self.last_response = {"text": content}
+                self.conversation.update_chat_history(prompt, content)
+                return self.last_response if not raw else content # Return dict or raw string
+
             except CurlError as e: # Catch CurlError
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
             except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
@@ -311,7 +324,7 @@ if __name__ == "__main__":
             response_text = ""
             for chunk in response:
                 response_text += chunk
-            
+
             if response_text and len(response_text.strip()) > 0:
                 status = "✓"
                 # Clean and truncate response
@@ -322,4 +335,4 @@ if __name__ == "__main__":
                 display_text = "Empty or invalid response"
             print(f"\r{model:<50} {status:<10} {display_text}")
         except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/ElectronHub.py

@@ -1,10 +1,13 @@
-import requests
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 import json
 import os
-from typing import Any, Dict, Optional, Generator, Union
+from typing import Any, Dict, Optional, Generator, Union, List
+
+import requests
 
 from webscout.AIutel import Optimizers
-from webscout.AIutel import Conversation
+from webscout.AIutel import Conversation, sanitize_stream # Import sanitize_stream
 from webscout.AIutel import AwesomePrompts, sanitize_stream
 from webscout.AIbase import Provider, AsyncProvider
 from webscout import exceptions
@@ -550,6 +553,13 @@ class ElectronHub(Provider):
             # Fallback to default models list if fetching fails
             pass
 
+    @staticmethod
+    def _electronhub_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from ElectronHub stream JSON objects."""
+        if isinstance(chunk, dict):
+            return chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+        return None
+
     def __init__(
         self,
         is_conversation: bool = True,
@@ -593,9 +603,9 @@ class ElectronHub(Provider):
         if api_key:
             self.headers['Authorization'] = f'Bearer {api_key}'
         self.system_prompt = system_prompt
-        self.session = requests.Session()
+        self.session = Session() # Use curl_cffi Session
         self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
+        self.session.proxies = proxies # Assign proxies directly
 
         self.is_conversation = is_conversation
         self.max_tokens = max_tokens
@@ -663,41 +673,38 @@ class ElectronHub(Provider):
 
         def for_stream():
             try:
-                with requests.post(self.url, headers=self.headers, data=json.dumps(payload), stream=True, timeout=self.timeout) as response:
-                    if response.status_code != 200:
-                        raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
-                        )
-                    
-                    streaming_text = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line:
-                            line = line.strip()
-                            if line.startswith("data: "):
-                                json_str = line[6:]
-                                if json_str == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(json_str)
-                                    if 'choices' in json_data:
-                                        choice = json_data['choices'][0]
-                                        if 'delta' in choice and 'content' in choice['delta']:
-                                            content = choice['delta']['content']
-                                            # Fix: Check if content is not None before concatenating
-                                            if content is not None:
-                                                streaming_text += content
-                                                resp = dict(text=content)
-                                                yield resp if raw else resp
-                                except json.JSONDecodeError:
-                                    continue
-                                except Exception as e:
-                                    print(f"Error processing chunk: {e}")
-                                    continue
-                    
-                    self.conversation.update_chat_history(prompt, streaming_text)
-                    
-            except requests.RequestException as e:
+                response = self.session.post(
+                    self.url, headers=self.headers, data=json.dumps(payload), stream=True, timeout=self.timeout,
+                    impersonate="chrome120" # Add impersonate
+                )
+                response.raise_for_status()
+
+                streaming_text = ""
+                # Use sanitize_stream
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value="data:",
+                    to_json=True,     # Stream sends JSON
+                    skip_markers=["[DONE]"],
+                    content_extractor=self._electronhub_extractor, # Use the specific extractor
+                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                )
+
+                for content_chunk in processed_stream:
+                    # content_chunk is the string extracted by _electronhub_extractor
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        resp = dict(text=content_chunk)
+                        yield resp if not raw else content_chunk
+
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
+            except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            finally:
+                # Update history after stream finishes or fails
+                if streaming_text:
+                    self.conversation.update_chat_history(prompt, streaming_text)
 
         def for_non_stream():
             collected_response = ""
@@ -710,7 +717,9 @@ class ElectronHub(Provider):
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Error during non-stream processing: {str(e)}")
             
+            # Update history and last_response after aggregation
             self.last_response = {"text": collected_response}
+            self.conversation.update_chat_history(prompt, collected_response)
             return self.last_response
 
         return for_stream() if stream else for_non_stream()

webscout/Provider/ExaChat.py

@@ -1,10 +1,11 @@
-import requests
+from curl_cffi import CurlError
+from curl_cffi.requests import Session, Response # Import Response
 import json
 import uuid
-from typing import Any, Dict, Union, Optional
+from typing import Any, Dict, Union, Optional, List
 from datetime import datetime
-from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
-from webscout.AIbase import Provider
+from webscout.AIutel import Optimizers, Conversation, AwesomePrompts, sanitize_stream # Import sanitize_stream
+from webscout.AIbase import Provider 
 from webscout import exceptions
 from webscout.litagent import LitAgent
 
@@ -22,6 +23,8 @@ MODEL_CONFIGS = {
             "gemini-2.0-flash-thinking-exp-01-21",
             "gemini-2.5-pro-exp-03-25",
             "gemini-2.0-pro-exp-02-05",
+            "gemini-2.5-flash-preview-04-17",
+
         
         ],
     },
@@ -87,6 +90,7 @@ class ExaChat(Provider):
         "gemini-2.0-flash-thinking-exp-01-21",
         "gemini-2.5-pro-exp-03-25",
         "gemini-2.0-pro-exp-02-05",
+        "gemini-2.5-flash-preview-04-17",
         
         # OpenRouter Models
         "mistralai/mistral-small-3.1-24b-instruct:free",
@@ -141,7 +145,7 @@ class ExaChat(Provider):
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
             
-        self.session = requests.Session()
+        self.session = Session() # Use curl_cffi Session
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.timeout = timeout
@@ -166,7 +170,7 @@ class ExaChat(Provider):
         }
         
         self.session.headers.update(self.headers)
-        self.session.proxies = proxies
+        self.session.proxies = proxies # Assign proxies directly
         self.session.cookies.update({"session": uuid.uuid4().hex})
 
         self.__available_optimizers = (
@@ -208,18 +212,27 @@ class ExaChat(Provider):
         error_msg = f"Invalid model: {model}\nAvailable models: {', '.join(available_models)}"
         raise ValueError(error_msg)
 
-    def _make_request(self, payload: Dict[str, Any]) -> requests.Response:
+    @staticmethod
+    def _exachat_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from ExaChat stream JSON objects."""
+        if isinstance(chunk, dict):
+            return chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+        return None
+
+    def _make_request(self, payload: Dict[str, Any]) -> Response: # Change type hint to Response
         """Make the API request with proper error handling."""
         try:
             response = self.session.post(
                 self._get_endpoint(),
                 headers=self.headers,
                 json=payload,
-                timeout=self.timeout,
+                timeout=self.timeout, # type: ignore
+                stream=True, # Enable streaming for the request
+                impersonate="chrome120" # Add impersonate
             )
             response.raise_for_status()
             return response
-        except requests.exceptions.RequestException as e:
+        except (CurlError, exceptions.FailedToGenerateResponseError, Exception) as e: # Catch CurlError and others
             raise exceptions.FailedToGenerateResponseError(f"API request failed: {e}") from e
 
     def _build_payload(self, conversation_prompt: str) -> Dict[str, Any]:
@@ -271,20 +284,23 @@ class ExaChat(Provider):
         
         try:
             full_response = ""
-            for line in response.iter_lines():
-                if line:
-                    try:
-                        data = json.loads(line.decode('utf-8'))
-                        if 'choices' in data and len(data['choices']) > 0:
-                            content = data['choices'][0].get('delta', {}).get('content', '')
-                            if content:
-                                full_response += content
-                    except json.JSONDecodeError:
-                        continue
+            # Use sanitize_stream to process the response
+            processed_stream = sanitize_stream(
+                data=response.iter_content(chunk_size=None), # Pass byte iterator
+                intro_value=None, # API doesn't seem to use 'data:' prefix
+                to_json=True,     # Stream sends JSON lines
+                content_extractor=self._exachat_extractor, # Use the specific extractor
+                yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+            )
+
+            for content_chunk in processed_stream:
+                # content_chunk is the string extracted by _exachat_extractor
+                if content_chunk and isinstance(content_chunk, str):
+                    full_response += content_chunk
                             
             self.last_response = {"text": full_response}
             self.conversation.update_chat_history(prompt, full_response)
-            return self.last_response
+            return self.last_response if not raw else full_response # Return dict or raw string
             
         except json.JSONDecodeError as e:
             raise exceptions.FailedToGenerateResponseError(f"Invalid JSON response: {e}") from e

webscout/Provider/GPTWeb.py

@@ -1,11 +1,11 @@
-from typing import Generator, Union
+from typing import Any, Dict, Generator, Optional, Union
 from curl_cffi.requests import Session
 from curl_cffi import CurlError
 import json
 
 from webscout import exceptions
 from webscout.AIutel import Optimizers
-from webscout.AIutel import Conversation
+from webscout.AIutel import Conversation, sanitize_stream # Import sanitize_stream
 from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 
@@ -75,6 +75,13 @@ class GPTWeb(Provider):
         )
         self.conversation.history_offset = history_offset
 
+    @staticmethod
+    def _gptweb_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from GPTWeb stream JSON objects."""
+        if isinstance(chunk, dict):
+            return chunk.get("gpt")
+        return None
+
     def ask(
         self,
         prompt: str,
@@ -129,22 +136,21 @@ class GPTWeb(Provider):
                 )
                 response.raise_for_status() # Check for HTTP errors
             
-                # Iterate over bytes and decode manually
-                for line_bytes in response.iter_lines():
-                    if line_bytes:
-                        try:
-                            line = line_bytes.decode('utf-8').lstrip('_') # Remove "_"
-                            # Attempt to parse the entire line as JSON
-                            json_data = json.loads(line)  
-                            content = json_data.get("gpt", "")
-                            if content: # Ensure content is not None or empty
-                                full_response = content # API seems to send the full response each time
-                                resp = dict(text=full_response)
-                                # Yield dict or raw string chunk (yielding full response each time)
-                                yield resp if not raw else full_response 
-                        except (json.JSONDecodeError, UnicodeDecodeError):
-                            # print(f"Skipping invalid JSON line: {line}") # Optional: for debugging
-                            continue # Ignore lines that are not valid JSON or cannot be decoded
+                # Use sanitize_stream
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value=None, # No standard prefix, potential '_' handled by json.loads
+                    to_json=True,     # Stream sends JSON lines
+                    content_extractor=self._gptweb_extractor, # Use the specific extractor
+                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                )
+
+                for content_chunk in processed_stream:
+                    # content_chunk is the full text extracted by _gptweb_extractor
+                    if content_chunk and isinstance(content_chunk, str):
+                        full_response = content_chunk # API sends full response each time
+                        resp = dict(text=full_response)
+                        yield resp if not raw else full_response
                 
                 # Update history after stream finishes (using the final full response)
                 self.last_response = dict(text=full_response)