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

webscout/Provider/searchchat.py

@@ -1,4 +1,5 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 from datetime import datetime
 from typing import Any, Dict, Optional, Generator, Union
@@ -26,7 +27,6 @@ class SearchChatAI(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        system_prompt: str = "You are a helpful assistant."
     ):
         """Initializes the SearchChatAI API client."""
         self.url = "https://search-chat.ai/api/chat-test-stop.php"
@@ -34,7 +34,6 @@ class SearchChatAI(Provider):
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.last_response = {}
-        self.system_prompt = system_prompt
         
         # Initialize LitAgent for user agent generation
         self.agent = LitAgent()
@@ -58,9 +57,11 @@ class SearchChatAI(Provider):
             "User-Agent": self.fingerprint["user_agent"],
         }
         
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
+        self.session.proxies = proxies # Assign proxies directly
 
         self.__available_optimizers = (
             method
@@ -99,7 +100,7 @@ class SearchChatAI(Provider):
             "User-Agent": self.fingerprint["user_agent"],
         })
         
-        # Update session headers
+        # Update session headers (already done in the original code, should work with curl_cffi session)
         for header, value in self.headers.items():
             self.session.headers[header] = value
         
@@ -152,62 +153,40 @@ class SearchChatAI(Provider):
 
         def for_stream():
             try:
-                with self.session.post(
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
                     self.url,
+                    # headers are set on the session
                     json=payload,
                     stream=True,
-                    timeout=self.timeout
-                ) as response:
-                    if response.status_code != 200:
+                    timeout=self.timeout,
+                    impersonate=self.fingerprint.get("browser_type", "chrome110") # Use fingerprint browser type
+                )
+                if response.status_code != 200:
+                    # Add identity refresh logic on 403/429
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        response = self.session.post(
+                            self.url,
+                            json=payload,
+                            stream=True,
+                            timeout=self.timeout,
+                            impersonate=self.fingerprint.get("browser_type", "chrome110") # Use updated fingerprint
+                        )
+                        if not response.ok:
+                             raise exceptions.FailedToGenerateResponseError(
+                                f"Request failed after identity refresh - ({response.status_code}, {response.reason}) - {response.text}"
+                            )
+                    else:
                         raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
+                            f"Request failed with status code {response.status_code} - {response.text}"
                         )
                     
-                    streaming_text = ""
-                    for line in response.iter_lines():
-                        if line:
-                            line = line.decode('utf-8')
-                            if line.startswith('data: '):
-                                data_str = line[6:]  # Remove 'data: ' prefix
-                                
-                                if data_str == '[DONE]':
-                                    break
-                                    
-                                try:
-                                    data = json.loads(data_str)
-                                    if "choices" in data and len(data["choices"]) > 0:
-                                        delta = data["choices"][0].get("delta", {})
-                                        if "content" in delta:
-                                            content = delta["content"]
-                                            streaming_text += content
-                                            resp = dict(text=content)
-                                            yield resp if raw else content
-                                except json.JSONDecodeError:
-                                    continue
-                    
-                    self.last_response = {"text": streaming_text}
-                    self.conversation.update_chat_history(prompt, streaming_text)
-                    
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
-
-        def for_non_stream():
-            try:
-                response = self.session.post(
-                    self.url,
-                    json=payload,
-                    stream=True,  # Keep streaming enabled
-                    timeout=self.timeout
-                )
-                if response.status_code != 200:
-                    raise exceptions.FailedToGenerateResponseError(
-                        f"Request failed with status code {response.status_code}"
-                    )
-                
-                full_text = ""
-                for line in response.iter_lines():
-                    if line:
-                        line = line.decode('utf-8')
+                streaming_text = ""
+                # Iterate over bytes and decode manually
+                for line_bytes in response.iter_lines():
+                    if line_bytes:
+                        line = line_bytes.decode('utf-8')
                         if line.startswith('data: '):
                             data_str = line[6:]  # Remove 'data: ' prefix
                             
@@ -218,21 +197,40 @@ class SearchChatAI(Provider):
                                 data = json.loads(data_str)
                                 if "choices" in data and len(data["choices"]) > 0:
                                     delta = data["choices"][0].get("delta", {})
-                                    if "content" in delta:
+                                    if "content" in delta and delta["content"] is not None:
                                         content = delta["content"]
-                                        full_text += content
-                            except json.JSONDecodeError:
+                                        streaming_text += content
+                                        resp = dict(text=content)
+                                        # Yield dict or raw string
+                                        yield resp if not raw else content
+                            except (json.JSONDecodeError, UnicodeDecodeError):
                                 continue
                 
-                if full_text:
-                    self.last_response = {"text": full_text}
-                    self.conversation.update_chat_history(prompt, full_text)
-                    return {"text": full_text}
-                else:
-                    raise exceptions.FailedToGenerateResponseError("No response content found")
+                # Update history and last response after stream finishes
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
                     
-            except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
+            except Exception as e: # Catch other potential exceptions
+                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
+
+        def for_non_stream():
+            # Aggregate the stream using the updated for_stream logic
+            full_text = ""
+            # Iterate through the generator provided by for_stream
+            # Ensure raw=False so for_stream yields dicts
+            for chunk_data in for_stream(): 
+                if isinstance(chunk_data, dict) and "text" in chunk_data:
+                    full_text += chunk_data["text"]
+                # If raw=True was somehow passed, handle string chunks
+                elif isinstance(chunk_data, str):
+                    full_text += chunk_data
+            
+            # last_response and history are updated within for_stream
+            # Return the final aggregated response dict or raw string
+            return full_text if raw else self.last_response
+
 
         return for_stream() if stream else for_non_stream()
 
@@ -255,16 +253,24 @@ class SearchChatAI(Provider):
         Returns:
             Either a string response or a generator for streaming
         """
-        def for_stream():
-            for response in self.ask(prompt, True, optimizer=optimizer, conversationally=conversationally):
-                yield self.get_message(response)
+        def for_stream_chat():
+            # ask() yields dicts or strings when streaming
+            gen = self.ask(
+                prompt, stream=True, raw=False, # Ensure ask yields dicts
+                optimizer=optimizer, conversationally=conversationally
+            )
+            for response_dict in gen:
+                yield self.get_message(response_dict) # get_message expects dict
                 
-        def for_non_stream():
-            return self.get_message(
-                self.ask(prompt, False, optimizer=optimizer, conversationally=conversationally)
+        def for_non_stream_chat():
+             # ask() returns dict or str when not streaming
+            response_data = self.ask(
+                prompt, stream=False, raw=False, # Ensure ask returns dict
+                optimizer=optimizer, conversationally=conversationally
             )
+            return self.get_message(response_data) # get_message expects dict
             
-        return for_stream() if stream else for_non_stream()
+        return for_stream_chat() if stream else for_non_stream_chat()
 
     def get_message(self, response: dict) -> str:
         """Extract the message from the response."""
@@ -272,6 +278,7 @@ class SearchChatAI(Provider):
         return response["text"]
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Status':<10} {'Response'}")
     print("-" * 80)
@@ -290,4 +297,4 @@ if __name__ == "__main__":
             display_text = "Empty or invalid response"
         print(f"{status:<10} {display_text}")
     except Exception as e:
-        print(f"{'✗':<10} {str(e)}") 
+        print(f"{'✗':<10} {str(e)}")

webscout/Provider/sonus.py

@@ -1,4 +1,5 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 from typing import Any, Dict, Optional, Generator, Union
 from webscout.AIutel import Optimizers
@@ -21,7 +22,7 @@ class SonusAI(Provider):
     def __init__(
         self,
         is_conversation: bool = True,
-        max_tokens: int = 2049,
+        max_tokens: int = 2049, # Note: max_tokens is not directly used by this API
         timeout: int = 30,
         intro: str = None,
         filepath: str = None,
@@ -44,11 +45,14 @@ class SonusAI(Provider):
             'Origin': 'https://chat.sonus.ai',
             'Referer': 'https://chat.sonus.ai/',
             'User-Agent': LitAgent().random()
+            # Add sec-ch-ua headers if needed for impersonation consistency
         }
         
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
+        # Update curl_cffi session headers and proxies
         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_to_sample = max_tokens
@@ -92,61 +96,95 @@ class SonusAI(Provider):
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
-        # Prepare the multipart form data
-        files = {
-            'message': (None, conversation_prompt),
-            'history': (None),
-            'reasoning': (None, str(reasoning).lower()),
-            'model': (None, self.model)
+        # Prepare the multipart form data (curl_cffi handles tuples for files/data)
+        # No need for explicit (None, ...) for simple fields when using `data=`
+        form_data = {
+            'message': conversation_prompt,
+            'history': "", # Explicitly empty string if needed, or omit if None is acceptable
+            'reasoning': str(reasoning).lower(),
+            'model': self.model
         }
+        # Note: curl_cffi's `files` parameter is for actual file uploads.
+        # For simple key-value pairs like this, `data` is usually sufficient for multipart/form-data.
+        # If the server strictly requires `files`, keep the original structure but it might not work as expected with curl_cffi without actual file objects.
 
         def for_stream():
             try:
-                with requests.post(self.url, files=files, headers=self.headers, stream=True, timeout=self.timeout) as response:
-                    if response.status_code != 200:
-                        raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
-                        )
+                # Use curl_cffi session post with impersonate
+                # Use `data` instead of `files` for simple key-value multipart
+                response = self.session.post(
+                    self.url, 
+                    # headers are set on the session
+                    data=form_data, # Use data for multipart form fields
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome110" # Use a common impersonation profile
+                )
+                if response.status_code != 200:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Request failed with status code {response.status_code} - {response.text}"
+                    )
                     
-                    streaming_text = ""
-                    for line in response.iter_lines():
-                        if line:
-                            try:
-                                # Decode the line and remove 'data: ' prefix if present
-                                line = line.decode('utf-8')
-                                if line.startswith('data: '):
-                                    line = line[6:]
-                                
-                                data = json.loads(line)
-                                if "content" in data:
-                                    content = data["content"]
-                                    streaming_text += content
-                                    resp = dict(text=content)
-                                    yield resp if raw else resp
-                            except (json.JSONDecodeError, UnicodeDecodeError):
+                streaming_text = ""
+                # Iterate over bytes and decode manually
+                for line_bytes in response.iter_lines():
+                    if line_bytes:
+                        try:
+                            # Decode the line and remove 'data: ' prefix if present
+                            line = line_bytes.decode('utf-8')
+                            if line.startswith('data: '):
+                                line = line[6:]
+                            
+                            # Handle potential empty lines after prefix removal
+                            if not line.strip():
                                 continue
+
+                            data = json.loads(line)
+                            if "content" in data:
+                                content = data["content"]
+                                streaming_text += content
+                                resp = dict(text=content)
+                                # Yield dict or raw string
+                                yield resp if raw else resp
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            continue
+                
+                # Update history and last response after stream finishes
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
                     
-                    self.last_response = {"text": streaming_text}
-                    self.conversation.update_chat_history(prompt, streaming_text)
-                    
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
+            except Exception as e: # Catch other potential exceptions
+                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
 
         def for_non_stream():
             try:
-                response = requests.post(self.url, files=files, headers=self.headers, timeout=self.timeout)
+                 # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.url, 
+                    # headers are set on the session
+                    data=form_data, # Use data for multipart form fields
+                    timeout=self.timeout,
+                    impersonate="chrome110" # Use a common impersonation profile
+                )
                 if response.status_code != 200:
                     raise exceptions.FailedToGenerateResponseError(
-                        f"Request failed with status code {response.status_code}"
+                        f"Request failed with status code {response.status_code} - {response.text}"
                     )
 
                 full_response = ""
-                for line in response.iter_lines():
+                # Process the full response text which might contain multiple JSON objects
+                # Split by lines and process each potential JSON object
+                for line in response.text.splitlines():
                     if line:
                         try:
-                            line = line.decode('utf-8')
                             if line.startswith('data: '):
                                 line = line[6:]
+                            
+                            if not line.strip():
+                                continue
+                                
                             data = json.loads(line)
                             if "content" in data:
                                 full_response += data["content"]
@@ -155,9 +193,13 @@ class SonusAI(Provider):
 
                 self.last_response = {"text": full_response}
                 self.conversation.update_chat_history(prompt, full_response)
-                return {"text": full_response}
-            except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+                # Return dict or raw string
+                return full_response if raw else {"text": full_response}
+                
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
 
         return for_stream() if stream else for_non_stream()
 
@@ -169,20 +211,30 @@ class SonusAI(Provider):
         conversationally: bool = False,
         reasoning: bool = False,
     ) -> Union[str, Generator[str, None, None]]:
-        def for_stream():
-            for response in self.ask(prompt, True, optimizer=optimizer, conversationally=conversationally, reasoning=reasoning):
-                yield self.get_message(response)
-        def for_non_stream():
-            return self.get_message(
-                self.ask(prompt, False, optimizer=optimizer, conversationally=conversationally, reasoning=reasoning)
+        def for_stream_chat():
+            # ask() yields dicts when raw=False
+            for response_dict in self.ask(
+                prompt, stream=True, raw=False, # Ensure ask yields dicts
+                optimizer=optimizer, conversationally=conversationally, reasoning=reasoning
+            ):
+                yield self.get_message(response_dict)
+        
+        def for_non_stream_chat():
+             # ask() returns dict or str when raw=False/True
+            response_data = self.ask(
+                prompt, stream=False, raw=False, # Ensure ask returns dict
+                optimizer=optimizer, conversationally=conversationally, reasoning=reasoning
             )
-        return for_stream() if stream else for_non_stream()
+            return self.get_message(response_data) # get_message expects dict
+
+        return for_stream_chat() if stream else for_non_stream_chat()
 
     def get_message(self, response: dict) -> str:
         assert isinstance(response, dict), "Response should be of dict data-type only"
         return response["text"]
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
@@ -205,4 +257,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)}")