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

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
@@ -15,6 +18,7 @@ class ElectronHub(Provider):
     A class to interact with the ElectronHub API with LitAgent user-agent.
     """
 
+    # Default models list (will be updated dynamically)
     AVAILABLE_MODELS = [
             # OpenAI GPT models
             "gpt-3.5-turbo",
@@ -498,6 +502,63 @@ class ElectronHub(Provider):
             "text-moderation-stable",
             "text-moderation-007"
         ]
+        
+    @classmethod
+    def get_models(cls, api_key: str = None):
+        """Fetch available models from ElectronHub API.
+        
+        Args:
+            api_key (str, optional): ElectronHub API key. If not provided, returns default models.
+            
+        Returns:
+            list: List of available model IDs
+        """
+        if not api_key:
+            return cls.AVAILABLE_MODELS
+            
+        try:
+            headers = {
+                'Content-Type': 'application/json',
+                'Accept': '*/*',
+                'User-Agent': LitAgent().random(),
+                'Authorization': f'Bearer {api_key}'
+            }
+            
+            response = requests.get(
+                "https://api.electronhub.top/v1/models",
+                headers=headers,
+                timeout=10
+            )
+            
+            if response.status_code != 200:
+                return cls.AVAILABLE_MODELS
+                
+            data = response.json()
+            if "data" in data and isinstance(data["data"], list):
+                return [model["id"] for model in data["data"]]
+            return cls.AVAILABLE_MODELS
+            
+        except Exception:
+            # Fallback to default models list if fetching fails
+            return cls.AVAILABLE_MODELS
+    
+    @classmethod
+    def update_available_models(cls, api_key=None):
+        """Update the available models list from ElectronHub API"""
+        try:
+            models = cls.get_models(api_key)
+            if models and len(models) > 0:
+                cls.AVAILABLE_MODELS = models
+        except Exception:
+            # 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,
@@ -515,6 +576,10 @@ class ElectronHub(Provider):
         api_key: str = None
     ):
         """Initializes the ElectronHub API client."""
+        # Update available models from API
+        self.update_available_models(api_key)
+        
+        # Validate model after updating available models
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
             
@@ -538,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
@@ -608,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 = ""
@@ -655,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,8 +1,11 @@
-import requests
+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
 
@@ -14,7 +17,7 @@ class GPTWeb(Provider):
     def __init__(
         self,
         is_conversation: bool = True,
-        max_tokens: int = 600,
+        max_tokens: int = 600, # Note: max_tokens is not used by this API
         timeout: int = 30,
         intro: str = None,
         filepath: str = None,
@@ -22,7 +25,7 @@ class GPTWeb(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-
+        # Note: system_prompt is not used by this API
     ):
         """
         Initializes the Nexra GPTWeb API with given parameters.
@@ -37,9 +40,9 @@ class GPTWeb(Provider):
             proxies (dict, optional): Http request proxies. Defaults to {}.
             history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
-            system_prompt (str, optional): System prompt for GPTWeb. Defaults to "You are a helpful AI assistant.".
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = 'https://nexra.aryahcr.cc/api/chat/gptweb'
@@ -48,6 +51,7 @@ class GPTWeb(Provider):
         self.last_response = {}
         self.headers = {
             "Content-Type": "application/json"
+            # Remove User-Agent, Accept-Encoding, etc. - handled by impersonate
         }
 
         self.__available_optimizers = (
@@ -55,7 +59,10 @@ class GPTWeb(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies # Assign proxies directly
+
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -67,16 +74,22 @@ class GPTWeb(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+
+    @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,
-        stream: bool = False,
+        stream: bool = False, # API supports streaming
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> dict:
+    ) -> Union[dict, Generator[dict, None, None]]: # Corrected return type hint
         """Chat with GPTWeb
 
         Args:
@@ -110,31 +123,65 @@ class GPTWeb(Provider):
         }
 
         def for_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, data=json.dumps(data), stream=True, timeout=self.timeout)
-            if not response.ok:
-                raise Exception(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            full_response = '' # Initialize outside try block
+            try:
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.api_endpoint, 
+                    # headers are set on the session
+                    data=json.dumps(data), 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome110" # Use a common impersonation profile
                 )
+                response.raise_for_status() # Check for HTTP errors
             
-            full_response = ''
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    line = line.lstrip('_') # Remove "_"
-                    try:
-                        # Attempt to parse the entire line as JSON
-                        json_data = json.loads(line)  
-                        full_response = json_data.get("gpt", "")
-                        yield full_response if raw else dict(text=full_response) 
-                    except json.JSONDecodeError:
-                        print(f"Skipping invalid JSON line: {line}") 
-            self.last_response.update(dict(text=full_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                # 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)
+                self.conversation.update_chat_history(
+                    prompt, full_response
+                )
+            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)
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"Failed to generate response ({type(e).__name__}): {e} - {err_text}") from e
+
+
         def for_non_stream():
-            for _ in for_stream():
-                pass
-            return self.last_response
+            # Aggregate the stream using the updated for_stream logic
+            # Since the stream yields the full response each time, we just need the last one.
+            last_chunk = None
+            try:
+                for chunk in for_stream():
+                    last_chunk = chunk
+            except Exception as e:
+                 # If aggregation fails, re-raise.
+                 raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
+
+            # last_response and history are updated within for_stream
+            # Return the final aggregated response dict or raw string
+            if last_chunk is None:
+                 raise exceptions.FailedToGenerateResponseError("No response received from stream.")
+            
+            return last_chunk # last_chunk is already dict or raw string based on 'raw'
+
 
         return for_stream() if stream else for_non_stream()
 
@@ -144,7 +191,7 @@ class GPTWeb(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> str:
+    ) -> Union[str, Generator[str, None, None]]: # Corrected return type hint
         """Generate response `str`
         Args:
             prompt (str): Prompt to be send.
@@ -155,23 +202,31 @@ class GPTWeb(Provider):
             str: Response generated
         """
 
-        def for_stream():
-            for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
-            ):
-                yield self.get_message(response)
-
-        def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
+        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
             )
+            # Since the API sends the full response each time, we only need the last one.
+            # However, to maintain the streaming interface, we yield the message from each chunk.
+            # This might result in repeated text if the client doesn't handle it.
+            # A better approach might be to track changes, but for simplicity, yield each message.
+            for response_dict in gen:
+                yield self.get_message(response_dict) 
+
+        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:
         """Retrieves message only from response
@@ -186,6 +241,7 @@ class GPTWeb(Provider):
         return response["text"]
 
 if __name__ == '__main__':
+    # Ensure curl_cffi is installed
     from rich import print
     ai = GPTWeb()
     response = ai.chat("tell me about Abhay koul, HelpingAI", stream=True)