webscout 7.9__py3-none-any.whl → 8.1__py3-none-any.whl

webscout/Provider/OPENAI/yep.py

@@ -0,0 +1,329 @@
+import time
+import uuid
+import cloudscraper  # Import cloudscraper
+import json
+from typing import List, Dict, Optional, Union, Generator, Any
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, get_system_prompt  # Import get_system_prompt
+)
+
+# Attempt to import LitAgent, fallback if not available
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    # Define a dummy LitAgent if webscout is not installed or accessible
+    class LitAgent:
+        def generate_fingerprint(self, browser: str = "chrome") -> Dict[str, Any]:
+            print("Warning: LitAgent not found. Using default minimal headers.")
+            return {
+                "accept": "*/*",
+                "accept_language": "en-US,en;q=0.9",
+                "platform": "Windows",
+                "sec_ch_ua": '"Not/A)Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
+                "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+                "browser_type": browser,
+            }
+
+# --- YEPCHAT Client ---
+
+# ANSI escape codes for formatting
+BOLD = "\033[1m"
+RED = "\033[91m"
+RESET = "\033[0m"
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'YEPCHAT'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = 1280,
+        stream: bool = False,
+        temperature: Optional[float] = 0.6,
+        top_p: Optional[float] = 0.7,
+        system_prompt: Optional[str] = None,  # Added for consistency, but will be ignored
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Creates a model response for the given chat conversation using YEPCHAT API.
+        Mimics openai.chat.completions.create
+        Note: YEPCHAT does not support system messages. They will be ignored.
+        """
+        if model not in self._client.AVAILABLE_MODELS:
+            raise ValueError(
+                f"Invalid model: {model}. Choose from: {self._client.AVAILABLE_MODELS}"
+            )
+
+        # Filter out system messages and warn the user if any are present
+        filtered_messages = []
+        has_system_message = False
+        if get_system_prompt(messages) or system_prompt:  # Check both message list and explicit param
+            has_system_message = True
+
+        for msg in messages:
+            if msg["role"] == "system":
+                continue  # Skip system messages
+            filtered_messages.append(msg)
+
+        if has_system_message:
+            # Print warning in bold red
+            print(f"{BOLD}{RED}Warning: YEPCHAT does not support system messages, they will be ignored.{RESET}")
+
+        # If no messages left after filtering, raise an error
+        if not filtered_messages:
+            raise ValueError("At least one user or assistant message is required for YEPCHAT.")
+
+        payload = {
+            "stream": stream,
+            "max_tokens": max_tokens,
+            "top_p": top_p,
+            "temperature": temperature,
+            "messages": filtered_messages,  # Use filtered messages
+            "model": model,
+        }
+
+        # Add any extra kwargs to the payload
+        payload.update(kwargs)
+
+        request_id = f"chatcmpl-{uuid.uuid4()}"
+        created_time = int(time.time())
+
+        if stream:
+            return self._create_stream(request_id, created_time, model, payload)
+        else:
+            return self._create_non_stream(request_id, created_time, model, payload)
+
+    def _create_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        try:
+            # Use session.post from cloudscraper instance
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                headers=self._client.headers,
+                cookies=self._client.cookies,
+                json=payload,
+                stream=True,
+                timeout=self._client.timeout
+            )
+
+            if not response.ok:
+                # Simplified error handling for now, add refresh logic if needed
+                raise IOError(
+                    f"YEPCHAT API Error: {response.status_code} {response.reason} - {response.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:
+                            data = json.loads(json_str)
+                            choice_data = data.get('choices', [{}])[0]
+                            delta_data = choice_data.get('delta', {})
+                            finish_reason = choice_data.get('finish_reason')
+                            content = delta_data.get('content')
+
+                            if content is not None:  # Only yield chunks with content
+                                delta = ChoiceDelta(content=content, role=delta_data.get('role', 'assistant'))
+                                choice = Choice(index=0, delta=delta, finish_reason=finish_reason)
+                                chunk = ChatCompletionChunk(
+                                    id=request_id,
+                                    choices=[choice],
+                                    created=created_time,
+                                    model=model,
+                                )
+                                yield chunk
+
+                        except json.JSONDecodeError:
+                            print(f"Warning: Could not decode JSON line: {json_str}")
+                            continue
+
+            # Yield final chunk with finish reason if not already sent
+            delta = ChoiceDelta()
+            choice = Choice(index=0, delta=delta, finish_reason="stop")  # Assume stop if loop finishes
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+            )
+            yield chunk
+
+        except cloudscraper.exceptions.CloudflareChallengeError as e:
+            pass
+
+    def _create_non_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+    ) -> ChatCompletion:
+        full_response_content = ""
+        finish_reason = "stop"  # Assume stop unless error occurs
+
+        try:
+            stream_generator = self._create_stream(request_id, created_time, model, payload)
+            for chunk in stream_generator:
+                if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
+                    full_response_content += chunk.choices[0].delta.content
+                if chunk.choices and chunk.choices[0].finish_reason:
+                    finish_reason = chunk.choices[0].finish_reason  # Capture finish reason if provided
+
+        except IOError as e:
+            print(f"Error obtaining non-stream response from YEPCHAT: {e}")
+            finish_reason = "error"
+
+        # Construct the final ChatCompletion object
+        message = ChatCompletionMessage(
+            role="assistant",
+            content=full_response_content
+        )
+        choice = Choice(
+            index=0,
+            message=message,
+            finish_reason=finish_reason
+        )
+        # Usage data is not provided by this API in a standard way, set to 0
+        usage = CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0)
+
+        completion = ChatCompletion(
+            id=request_id,
+            choices=[choice],
+            created=created_time,
+            model=model,
+            usage=usage,
+        )
+        return completion
+
+class Chat(BaseChat):
+    def __init__(self, client: 'YEPCHAT'):
+        self.completions = Completions(client)
+
+class YEPCHAT(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for YEPCHAT API.
+
+    Usage:
+        client = YEPCHAT()
+        response = client.chat.completions.create(
+            model="DeepSeek-R1-Distill-Qwen-32B",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+        print(response.choices[0].message.content)
+    """
+    AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        browser: str = "chrome"
+    ):
+        """
+        Initialize the YEPCHAT client.
+
+        Args:
+            timeout: Request timeout in seconds.
+            browser: Browser name for LitAgent to generate User-Agent.
+        """
+        self.timeout = timeout
+        self.api_endpoint = "https://api.yep.com/v1/chat/completions"
+        self.session = cloudscraper.create_scraper()  # Use cloudscraper
+
+        # Initialize LitAgent for user agent generation and fingerprinting
+        try:
+            agent = LitAgent()
+            fingerprint = agent.generate_fingerprint(browser=browser)
+        except Exception as e:
+            print(f"Warning: Failed to generate fingerprint with LitAgent: {e}. Using fallback.")
+            # Fallback fingerprint data
+            fingerprint = {
+                "accept": "*/*",
+                "accept_language": "en-US,en;q=0.9",
+                "sec_ch_ua": '"Not/A)Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
+                "platform": "Windows",
+                "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
+            }
+
+        # Initialize headers using the fingerprint
+        self.headers = {
+            "Accept": fingerprint["accept"],
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": fingerprint["accept_language"],
+            "Content-Type": "application/json; charset=utf-8",
+            "DNT": "1",
+            "Origin": "https://yep.com",
+            "Referer": "https://yep.com/",
+            "Sec-CH-UA": fingerprint["sec_ch_ua"] or '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{fingerprint["platform"]}"',
+            "User-Agent": fingerprint["user_agent"],
+        }
+        self.session.headers.update(self.headers)
+
+        # Generate cookies (consider if these need refreshing or specific values)
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+
+        # Initialize the chat interface
+        self.chat = Chat(self)
+
+    def convert_model_name(self, model: str) -> str:
+        """
+        Ensures the model name is valid for YEPCHAT.
+        Returns the validated model name or raises an error if invalid.
+        """
+        if model in self.AVAILABLE_MODELS:
+            return model
+        else:
+            # Raise error instead of defaulting, as model is mandatory in create()
+            raise ValueError(f"Model '{model}' not supported by YEPCHAT. Available: {self.AVAILABLE_MODELS}")
+
+# Example usage (optional, for testing)
+if __name__ == '__main__':
+    print("Testing YEPCHAT OpenAI-Compatible Client...")
+
+    # Test Non-Streaming
+    try:
+        print("\n--- Non-Streaming Test (DeepSeek) ---")
+        client = YEPCHAT()
+        response = client.chat.completions.create(
+            model="DeepSeek-R1-Distill-Qwen-32B",
+            messages=[
+                {"role": "user", "content": "Say 'Hello World'"}
+            ],
+            stream=False
+        )
+        print("Response:", response.choices[0].message.content)
+        print("Usage:", response.usage)  # Will show 0 tokens
+    except Exception as e:
+        print(f"Non-Streaming Test Failed: {e}")
+
+    # Test Streaming
+    try:
+        print("\n--- Streaming Test (Mixtral) ---")
+        client_stream = YEPCHAT()
+        stream = client_stream.chat.completions.create(
+            model="Mixtral-8x7B-Instruct-v0.1",
+            messages=[
+                {"role": "user", "content": "Write a short sentence about AI."}
+            ],
+            stream=True
+        )
+        print("Streaming Response:")
+        full_stream_response = ""
+        for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content:
+                print(content, end="", flush=True)
+                full_stream_response += content
+        print("\n--- End of Stream ---")
+        print("Full streamed text:", full_stream_response)
+    except Exception as e:
+        print(f"Streaming Test Failed: {e}")

webscout/Provider/OpenGPT.py

@@ -0,0 +1,199 @@
+import requests
+import json
+from typing import Dict, Generator, Union
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+
+class OpenGPT(Provider):
+    """
+    A class to interact with the Open-GPT API.
+    """
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        app_id: str = "clf3yg8730000ih08ndbdi2v4",
+    ):
+        """Initializes the OpenGPT API client.
+        
+        Args:
+            is_conversation (bool, optional): Whether to maintain conversation history. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            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, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            app_id (str, optional): The OpenGPT application ID. Defaults to "clf3yg8730000ih08ndbdi2v4".
+        """
+        self.session = requests.Session()
+        self.agent = LitAgent()
+        
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.app_id = app_id
+        
+        # Set up headers with dynamic user agent
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": self.agent.random(),
+            "Referer": f"https://open-gpt.app/id/app/{app_id}"
+        }
+        
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        
+        # Initialize optimizers
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        
+        # Setup conversation
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            ) if act else intro or Conversation.intro
+        )
+        
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict, Generator]:
+        """
+        Send a prompt to the OpenGPT API and get a response.
+        
+        Args:
+            prompt: The user input/prompt for the API.
+            stream: Whether to stream the response.
+            raw: Whether to return the raw API response.
+            optimizer: Optimizer to use on the prompt.
+            conversationally: Whether to apply the optimizer on the full conversation prompt.
+            
+        Returns:
+            A dictionary or generator with the response.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
+                
+        # Prepare the request body payload
+        payload = {
+            "userInput": conversation_prompt,
+            "id": self.app_id,
+            "userKey": ""  # Assuming userKey is meant to be empty as in the original code
+        }
+        
+        def for_non_stream():
+            try:
+                response = self.session.post(
+                    "https://open-gpt.app/api/generate",
+                    data=json.dumps(payload),
+                    timeout=self.timeout
+                )
+                
+                # Raise an exception for bad status codes
+                response.raise_for_status()
+                
+                response_text = response.text
+                self.last_response = {"text": response_text}
+                self.conversation.update_chat_history(prompt, response_text)
+                
+                return {"text": response_text} if not raw else {"raw": response_text}
+                
+            except requests.exceptions.RequestException as e:
+                # Handle potential errors during the request
+                error_msg = f"Error fetching data: {e}"
+                raise exceptions.FailedToGenerateResponseError(error_msg)
+            except Exception as e:
+                # Catch any other unexpected errors
+                error_msg = f"An unexpected error occurred: {e}"
+                raise exceptions.FailedToGenerateResponseError(error_msg)
+        
+        # This provider doesn't support streaming, so just return non-stream
+        return for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Send a prompt to the OpenGPT API and get a text response.
+        
+        Args:
+            prompt: The user input/prompt for the API.
+            stream: Whether to stream the response (not supported).
+            optimizer: Optimizer to use on the prompt.
+            conversationally: Whether to apply the optimizer on the full conversation prompt.
+            
+        Returns:
+            A string with the response text.
+        """
+        response = self.ask(
+            prompt, False, optimizer=optimizer, conversationally=conversationally
+        )
+        return self.get_message(response)
+
+    def get_message(self, response: dict) -> str:
+        """
+        Extract the message from the response dictionary.
+        
+        Args:
+            response: Response dictionary from the ask method.
+            
+        Returns:
+            The text response as a string.
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+
+if __name__ == "__main__":
+    # Test the provider
+    print("-" * 80)
+    print("Testing OpenGPT provider")
+    print("-" * 80)
+    
+    try:
+        test_ai = OpenGPT()
+        response = test_ai.chat("Explain quantum physics simply.")
+        print(response)
+    except Exception as e:
+        print(f"Error: {e}")
+

webscout/Provider/PI.py

@@ -50,7 +50,7 @@ class PiAI(Provider):
     ):
         """
         Initializes PiAI with voice support.
-        
+
         Args:
             voice (bool): Enable/disable voice output
             voice_name (str): Name of the voice to use (if None, uses default)
@@ -66,7 +66,9 @@ class PiAI(Provider):
 
         # Initialize other attributes
         self.scraper = cloudscraper.create_scraper()
-        self.url = 'https://pi.ai/api/chat'
+        self.primary_url = 'https://pi.ai/api/chat'
+        self.fallback_url = 'https://pi.ai/api/v2/chat'
+        self.url = self.primary_url
         self.headers = {
             'Accept': 'text/event-stream',
             'Accept-Encoding': 'gzip, deflate, br, zstd',
@@ -115,7 +117,7 @@ class PiAI(Provider):
         )
         self.conversation.history_offset = history_offset
         self.session.proxies = proxies
-        
+
         if self.is_conversation:
             self.start_conversation()
 
@@ -130,13 +132,13 @@ class PiAI(Provider):
             json={},
             timeout=self.timeout
         )
-        
+
         if not response.ok:
             raise Exception(f"Failed to start conversation: {response.status_code}")
-            
+
         data = response.json()
         self.conversation_id = data['conversations'][0]['sid']
-        
+
         return self.conversation_id
 
     def ask(
@@ -152,7 +154,7 @@ class PiAI(Provider):
     ) -> dict:
         """
         Interact with Pi.ai by sending a prompt and receiving a response.
-        
+
         Args:
             prompt (str): The prompt to send
             stream (bool): Whether to stream the response
@@ -186,15 +188,28 @@ class PiAI(Provider):
         }
 
         def process_stream():
+            # Try primary URL first
             response = self.scraper.post(
-                self.url, 
-                headers=self.headers, 
-                cookies=self.cookies, 
-                json=data, 
-                stream=True, 
+                self.url,
+                headers=self.headers,
+                cookies=self.cookies,
+                json=data,
+                stream=True,
                 timeout=self.timeout
             )
-            
+
+            # If primary URL fails, try fallback URL
+            if not response.ok and self.url == self.primary_url:
+                self.url = self.fallback_url
+                response = self.scraper.post(
+                    self.url,
+                    headers=self.headers,
+                    cookies=self.cookies,
+                    json=data,
+                    stream=True,
+                    timeout=self.timeout
+                )
+
             if not response.ok:
                 raise Exception(f"API request failed: {response.status_code}")
 
@@ -204,7 +219,7 @@ class PiAI(Provider):
 
             if voice and voice_name and second_sid:
                 threading.Thread(
-                    target=self.download_audio_threaded, 
+                    target=self.download_audio_threaded,
                     args=(voice_name, second_sid, output_file)
                 ).start()
 
@@ -245,7 +260,7 @@ class PiAI(Provider):
     ) -> str:
         """
         Generates a response based on the provided prompt.
-        
+
         Args:
             prompt (str): The prompt to send
             stream (bool): Whether to stream the response
@@ -300,24 +315,24 @@ class PiAI(Provider):
             'voice': f'voice{self.AVAILABLE_VOICES[voice_name]}',
             'messageSid': second_sid,
         }
-        
+
         try:
             audio_response = self.scraper.get(
-                'https://pi.ai/api/chat/voice', 
-                params=params, 
-                cookies=self.cookies, 
-                headers=self.headers, 
+                'https://pi.ai/api/chat/voice',
+                params=params,
+                cookies=self.cookies,
+                headers=self.headers,
                 timeout=self.timeout
             )
-            
+
             if not audio_response.ok:
                 return
-                
+
             audio_response.raise_for_status()
-            
+
             with open(output_file, "wb") as file:
                 file.write(audio_response.content)
-                
+
         except requests.exceptions.RequestException:
             pass
 

webscout/Provider/Venice.py

@@ -16,7 +16,7 @@ class Venice(Provider):
     """
     
     AVAILABLE_MODELS = [
-        "llama-3.3-70b",
+        "mistral-31-24b",
         "llama-3.2-3b-akash",
         "qwen2dot5-coder-32b",
         "deepseek-coder-v2-lite",