webscout 8.2.7__py3-none-any.whl → 8.2.9__py3-none-any.whl

webscout/Provider/OPENAI/yep.py

@@ -0,0 +1,382 @@
+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, count_tokens  # Import count_tokens
+)
+
+# 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.
+        """
+        # Only accept and use the raw model name (no prefix logic)
+        model_raw = model
+        # Validate model
+        if model_raw 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_raw,  # Send only the raw model name to the API
+        }
+
+        # 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:
+            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:
+                raise IOError(
+                    f"YEPCHAT API Error: {response.status_code} {response.reason} - {response.text}"
+                )
+
+            # Track tokens for streaming
+            prompt_tokens = count_tokens([m.get('content', '') for m in payload.get('messages', [])])
+            completion_tokens = 0
+            total_tokens = prompt_tokens
+
+            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')
+                            role = delta_data.get('role', None)
+
+                            # Count tokens for this chunk
+                            chunk_tokens = count_tokens(content) if content else 0
+                            completion_tokens += chunk_tokens
+                            total_tokens = prompt_tokens + completion_tokens
+
+                            if content is not None or role is not None:
+                                delta = ChoiceDelta(content=content, role=role)
+                                choice = Choice(index=0, delta=delta, finish_reason=finish_reason)
+                                chunk = ChatCompletionChunk(
+                                    id=request_id,
+                                    choices=[choice],
+                                    created=created_time,
+                                    model=model,
+                                )
+                                # Set usage directly on the chunk object
+                                chunk.usage = {
+                                    "prompt_tokens": prompt_tokens,
+                                    "completion_tokens": completion_tokens,
+                                    "total_tokens": total_tokens,
+                                    "estimated_cost": None
+                                }
+                                # Yield the chunk with usage information
+                                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")
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+            )
+            # Set usage directly on the chunk object
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            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"
+        try:
+            # Make a non-streaming request to the API
+            payload_copy = payload.copy()
+            payload_copy["stream"] = False
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                headers=self._client.headers,
+                cookies=self._client.cookies,
+                json=payload_copy,
+                timeout=self._client.timeout
+            )
+            if not response.ok:
+                raise IOError(
+                    f"YEPCHAT API Error: {response.status_code} {response.reason} - {response.text}"
+                )
+            data = response.json()
+            if 'choices' in data and len(data['choices']) > 0:
+                # YEPCHAT non-streaming returns message content in choices[0]['message']['content']
+                full_response_content = data['choices'][0].get('message', {}).get('content', '')
+                finish_reason = data['choices'][0].get('finish_reason', 'stop')
+            else:
+                full_response_content = ''
+                finish_reason = 'stop'
+        except Exception as e:
+            print(f"Error obtaining non-stream response from YEPCHAT: {e}")
+            finish_reason = "error"
+
+        message = ChatCompletionMessage(
+            role="assistant",
+            content=full_response_content
+        )
+        choice = Choice(
+            index=0,
+            message=message,
+            finish_reason=finish_reason
+        )
+        # Use count_tokens to compute usage
+        prompt_tokens = count_tokens([m.get('content', '') for m in payload.get('messages', [])])
+        completion_tokens = count_tokens(full_response_content)
+        usage = CompletionUsage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=prompt_tokens + completion_tokens
+        )
+        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)
+    """
+    _base_models = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
+
+    # Create AVAILABLE_MODELS as a list of base model names (no prefix)
+    AVAILABLE_MODELS = _base_models
+
+    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)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return YEPCHAT.AVAILABLE_MODELS
+        return _ModelList()
+
+    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:")
+        for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content:
+                print(content, end="", flush=True)
+        print()  # Add a newline at the end
+
+    except Exception as e:
+        print(f"Streaming Test Failed: {e}")

webscout/Provider/OpenGPT.py

@@ -0,0 +1,209 @@
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+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, # Note: max_tokens is not used by this API
+        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".
+        """
+        # Initialize curl_cffi Session
+        self.session = Session()
+        self.agent = LitAgent() # Keep for potential future use or other headers
+        
+        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 (remove User-Agent if using impersonate)
+        self.headers = {
+            "Content-Type": "application/json",
+            # "User-Agent": self.agent.random(), # Removed, handled by impersonate
+            "Referer": f"https://open-gpt.app/id/app/{self.app_id}",
+            # Add sec-ch-ua headers if needed for impersonation consistency
+        }
+        
+        # Update curl_cffi session headers and proxies
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies # Assign proxies directly
+        
+        # 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, # Note: API does not support streaming
+        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
+        }
+        
+        # API does not stream, implement non-stream logic directly
+        def for_non_stream():
+            try:
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    "https://open-gpt.app/api/generate",
+                    # headers are set on the session
+                    data=json.dumps(payload), # Keep data as JSON string
+                    timeout=self.timeout,
+                    # proxies are set on the session
+                    impersonate="chrome110" # Use a common impersonation profile
+                )
+                
+                response.raise_for_status() # Check for HTTP errors
+                
+                # Use response.text which is already decoded
+                response_text = response.text
+                self.last_response = {"text": response_text}
+                self.conversation.update_chat_history(prompt, response_text)
+                
+                # Return dict or raw string based on raw flag
+                return {"raw": response_text} if raw else {"text": response_text}
+                
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+            except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
+        
+        # This provider doesn't support streaming, so just return non-stream
+        return for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False, # Keep stream param for interface consistency
+        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.
+        """
+        # Since ask() now handles both stream=True/False by returning the full response dict:
+        response_data = self.ask(
+            prompt, 
+            stream=False, # Call ask in non-stream mode internally
+            raw=False, # Ensure ask returns dict with 'text' key
+            optimizer=optimizer, 
+            conversationally=conversationally
+        )
+        # If stream=True was requested, simulate streaming by yielding the full message at once
+        if stream:
+            def stream_wrapper():
+                yield self.get_message(response_data)  # yield only the text string
+            return stream_wrapper()
+        else:
+            # If stream=False, return the full message directly
+            return self.get_message(response_data)
+
+    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__":
+    ai = OpenGPT()
+    print(ai.chat("Hello, how are you?"))