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

webscout/Provider/GPTWeb.py

@@ -1,6 +1,9 @@
-import requests
+from typing import Generator, 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 AwesomePrompts
@@ -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,15 @@ class GPTWeb(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
 
     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 +116,66 @@ 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)
-            )
+                # 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
+                
+                # 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 +185,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 +196,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 +235,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)

webscout/Provider/Groq.py

@@ -1,12 +1,15 @@
 from typing import Any, AsyncGenerator, Dict, Optional, Callable, List, Union
 
 import httpx
-import requests
 import json
 
+# Import curl_cffi for improved request handling
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider, AsyncProvider
 from webscout import exceptions
 
@@ -15,6 +18,7 @@ class GROQ(Provider):
     A class to interact with the GROQ AI API.
     """
 
+    # Default models list (will be updated dynamically)
     AVAILABLE_MODELS = [
         "distil-whisper-large-v3-en",
         "gemma2-9b-it",
@@ -42,6 +46,45 @@ class GROQ(Provider):
         "llama-3.2-90b-vision-preview",
         "mixtral-8x7b-32768"
     ]
+    
+    @classmethod
+    def get_models(cls, api_key: str = None):
+        """Fetch available models from Groq API.
+        
+        Args:
+            api_key (str, optional): Groq API key. If not provided, returns default models.
+            
+        Returns:
+            list: List of available model IDs
+        """
+        if not api_key:
+            return cls.AVAILABLE_MODELS
+            
+        try:
+            # Use a temporary curl_cffi session for this class method
+            temp_session = Session()
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            }
+            
+            response = temp_session.get(
+                "https://api.groq.com/openai/v1/models",
+                headers=headers,
+                impersonate="chrome110"  # Use impersonate for fetching
+            )
+            
+            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 (CurlError, Exception):
+            # Fallback to default models list if fetching fails
+            return cls.AVAILABLE_MODELS
 
     def __init__(
         self,
@@ -82,10 +125,15 @@ class GROQ(Provider):
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
             system_prompt (str, optional): System prompt to guide the conversation. Defaults to None.
         """
+        # 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}")
 
-        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_key = api_key
@@ -110,7 +158,11 @@ class GROQ(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        
+        # Update curl_cffi session headers
         self.session.headers.update(self.headers)
+        
+        # Set up conversation
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -122,7 +174,20 @@ class GROQ(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
+        
+        # Set proxies for curl_cffi session
         self.session.proxies = proxies
+    
+    @classmethod
+    def update_available_models(cls, api_key=None):
+        """Update the available models list from Groq 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
 
     def add_function(self, function_name: str, function: Callable):
         """Add a function to the available functions dictionary.
@@ -183,32 +248,42 @@ class GROQ(Provider):
         }
 
         def for_stream():
-            response = self.session.post(
-                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
-            )
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try:
+                response = self.session.post(
+                    self.chat_endpoint, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome110"  # Use impersonate for better compatibility
                 )
+                if not response.status_code == 200:
+                    raise exceptions.FailedToGenerateResponseError(
+                        # Removed response.reason_phrase
+                        f"Failed to generate response - ({response.status_code}) - {response.text}"
+                    )
 
-            message_load = ""
-            for value in response.iter_lines(
-                decode_unicode=True,
-                delimiter="" if raw else "data:",
-                chunk_size=self.stream_chunk_size,
-            ):
-                try:
-                    resp = json.loads(value)
-                    incomplete_message = self.get_message(resp)
-                    if incomplete_message:
-                        message_load += incomplete_message
-                        resp["choices"][0]["delta"]["content"] = message_load
-                        self.last_response.update(resp)
-                        yield value if raw else resp
-                    elif raw:
-                        yield value
-                except json.decoder.JSONDecodeError:
-                    pass
+                message_load = ""
+                for value in response.iter_lines(
+                    decode_unicode=True,
+                    delimiter="" if raw else "data:",
+                    chunk_size=self.stream_chunk_size,
+                ):
+                    try:
+                        resp = json.loads(value)
+                        incomplete_message = self.get_message(resp)
+                        if incomplete_message:
+                            message_load += incomplete_message
+                            resp["choices"][0]["delta"]["content"] = message_load
+                            self.last_response.update(resp)
+                            yield value if raw else resp
+                        elif raw:
+                            yield value
+                    except json.decoder.JSONDecodeError:
+                        pass
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"CurlError: {str(e)}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Error: {str(e)}")
 
             # Handle tool calls if any
             if 'tool_calls' in self.last_response.get('choices', [{}])[0].get('message', {}):
@@ -226,32 +301,54 @@ class GROQ(Provider):
                         })
                         payload['messages'] = messages
                         # Make a second call to get the final response
-                        second_response = self.session.post(
-                            self.chat_endpoint, json=payload, timeout=self.timeout
-                        )
-                        if second_response.ok:
-                            self.last_response = second_response.json()
-                        else:
-                            raise exceptions.FailedToGenerateResponseError(
-                                f"Failed to execute tool - {second_response.text}"
+                        try:
+                            second_response = self.session.post(
+                                self.chat_endpoint, 
+                                json=payload, 
+                                timeout=self.timeout,
+                                impersonate="chrome110"  # Use impersonate for better compatibility
                             )
+                            if second_response.status_code == 200:
+                                self.last_response = second_response.json()
+                            else:
+                                raise exceptions.FailedToGenerateResponseError(
+                                    f"Failed to execute tool - {second_response.text}"
+                                )
+                        except CurlError as e:
+                            raise exceptions.FailedToGenerateResponseError(f"CurlError during tool execution: {str(e)}")
+                        except Exception as e:
+                            raise exceptions.FailedToGenerateResponseError(f"Error during tool execution: {str(e)}")
 
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
 
         def for_non_stream():
-            response = self.session.post(
-                self.chat_endpoint, json=payload, stream=False, timeout=self.timeout
-            )
-            if (
-                not response.ok
-                or not response.headers.get("Content-Type", "") == "application/json"
-            ):
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try:
+                response = self.session.post(
+                    self.chat_endpoint, 
+                    json=payload, 
+                    stream=False, 
+                    timeout=self.timeout,
+                    impersonate="chrome110"  # Use impersonate for better compatibility
                 )
-            resp = response.json()
+                if (
+                    not response.status_code == 200
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                         # Removed response.reason_phrase
+                        f"Failed to generate response - ({response.status_code}) - {response.text}"
+                    )
+                resp = response.json()
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"CurlError: {str(e)}")
+            except Exception as e:
+                # Catch the original AttributeError here if it happens before the raise
+                if isinstance(e, AttributeError) and 'reason_phrase' in str(e):
+                     raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}) - {response.text}"
+                    )
+                raise exceptions.FailedToGenerateResponseError(f"Error: {str(e)}")
 
             # Handle tool calls if any
             if 'tool_calls' in resp.get('choices', [{}])[0].get('message', {}):
@@ -269,15 +366,23 @@ class GROQ(Provider):
                         })
                         payload['messages'] = messages
                         # Make a second call to get the final response
-                        second_response = self.session.post(
-                            self.chat_endpoint, json=payload, timeout=self.timeout
-                        )
-                        if second_response.ok:
-                            resp = second_response.json()
-                        else:
-                            raise exceptions.FailedToGenerateResponseError(
-                                f"Failed to execute tool - {second_response.text}"
+                        try:
+                            second_response = self.session.post(
+                                self.chat_endpoint, 
+                                json=payload, 
+                                timeout=self.timeout,
+                                impersonate="chrome110"  # Use impersonate for better compatibility
                             )
+                            if second_response.status_code == 200:
+                                resp = second_response.json()
+                            else:
+                                raise exceptions.FailedToGenerateResponseError(
+                                    f"Failed to execute tool - {second_response.text}"
+                                )
+                        except CurlError as e:
+                            raise exceptions.FailedToGenerateResponseError(f"CurlError during tool execution: {str(e)}")
+                        except Exception as e:
+                            raise exceptions.FailedToGenerateResponseError(f"Error during tool execution: {str(e)}")
 
             self.last_response.update(resp)
             self.conversation.update_chat_history(
@@ -287,7 +392,6 @@ class GROQ(Provider):
 
         return for_stream() if stream else for_non_stream()
 
-
     def chat(
         self,
         prompt: str,
@@ -337,11 +441,16 @@ class GROQ(Provider):
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
         try:
-            if response["choices"][0].get("delta"):
+            # Check delta first for streaming
+            if response.get("choices") and response["choices"][0].get("delta") and response["choices"][0]["delta"].get("content"):
                 return response["choices"][0]["delta"]["content"]
-            return response["choices"][0]["message"]["content"]
-        except KeyError:
-            return ""
+            # Check message content for non-streaming or final message
+            if response.get("choices") and response["choices"][0].get("message") and response["choices"][0]["message"].get("content"):
+                return response["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError):
+            # Handle cases where the structure might be different or content is null/missing
+            pass
+        return "" # Return empty string if no content found
 
 
 class AsyncGROQ(AsyncProvider):
@@ -349,33 +458,8 @@ class AsyncGROQ(AsyncProvider):
     An asynchronous class to interact with the GROQ AI API.
     """
 
-    AVAILABLE_MODELS = [
-        "distil-whisper-large-v3-en",
-        "gemma2-9b-it",
-        "llama-3.3-70b-versatile",
-        "llama-3.1-8b-instant",
-        "llama-guard-3-8b",
-        "llama3-70b-8192",
-        "llama3-8b-8192",
-        "whisper-large-v3",
-        "whisper-large-v3-turbo",
-        "meta-llama/llama-4-scout-17b-16e-instruct",
-        "meta-llama/llama-4-maverick-17b-128e-instruct",
-        "playai-tts",
-        "playai-tts-arabic",
-        "qwen-qwq-32b",
-        "mistral-saba-24b",
-        "qwen-2.5-coder-32b",
-        "qwen-2.5-32b",
-        "deepseek-r1-distill-qwen-32b",
-        "deepseek-r1-distill-llama-70b",
-        "llama-3.3-70b-specdec",
-        "llama-3.2-1b-preview",
-        "llama-3.2-3b-preview",
-        "llama-3.2-11b-vision-preview",
-        "llama-3.2-90b-vision-preview",
-        "mixtral-8x7b-32768"
-    ]
+    # Use the same model list as the synchronous class
+    AVAILABLE_MODELS = GROQ.AVAILABLE_MODELS
 
     def __init__(
         self,
@@ -416,6 +500,10 @@ class AsyncGROQ(AsyncProvider):
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
             system_prompt (str, optional): System prompt to guide the conversation. Defaults to None.
         """
+        # Update available models from API
+        GROQ.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}")
 
@@ -518,7 +606,8 @@ class AsyncGROQ(AsyncProvider):
             ) as response:
                 if not response.is_success:
                     raise exceptions.FailedToGenerateResponseError(
-                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                        # Removed response.reason_phrase (not available in httpx response)
+                        f"Failed to generate response - ({response.status_code})"
                     )
 
                 message_load = ""
@@ -575,7 +664,8 @@ class AsyncGROQ(AsyncProvider):
             )
             if not response.is_success:
                 raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    # Removed response.reason_phrase (not available in httpx response)
+                    f"Failed to generate response - ({response.status_code})"
                 )
             resp = response.json()
 
@@ -663,8 +753,21 @@ class AsyncGROQ(AsyncProvider):
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
         try:
-            if response["choices"][0].get("delta"):
+            # Check delta first for streaming
+            if response.get("choices") and response["choices"][0].get("delta") and response["choices"][0]["delta"].get("content"):
                 return response["choices"][0]["delta"]["content"]
-            return response["choices"][0]["message"]["content"]
-        except KeyError:
-            return ""
+            # Check message content for non-streaming or final message
+            if response.get("choices") and response["choices"][0].get("message") and response["choices"][0]["message"].get("content"):
+                return response["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError):
+             # Handle cases where the structure might be different or content is null/missing
+            pass
+        return "" # Return empty string if no content found
+        
+if __name__ == "__main__":
+    # Example usage
+    api_key = "gsk_*******************************"
+    groq = GROQ(api_key=api_key, model="compound-beta")
+    prompt = "What is the capital of France?"
+    response = groq.chat(prompt)
+    print(response)