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

webscout/Provider/OPENAI/wisecat.py

@@ -1,381 +0,0 @@
-import time
-import uuid
-import requests
-import re
-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
-)
-
-# 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]:
-            # Return minimal default headers if LitAgent is unavailable
-            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,
-            }
-
-# --- WiseCat Client ---
-
-class Completions(BaseCompletions):
-    def __init__(self, client: 'WiseCat'):
-        self._client = client
-
-    def create(
-        self,
-        *,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = 2049,
-        stream: bool = False,
-        temperature: Optional[float] = None,
-        top_p: Optional[float] = None,
-        **kwargs: Any
-    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a model response for the given chat conversation.
-        Mimics openai.chat.completions.create
-        """
-        # Prepare the payload for WiseCat API
-        payload = {
-            "id": "ephemeral",
-            "messages": messages,
-            "selectedChatModel": self._client.convert_model_name(model)
-        }
-
-        # Add optional parameters if provided
-        if max_tokens is not None and max_tokens > 0:
-            payload["max_tokens"] = max_tokens
-
-        if temperature is not None:
-            payload["temperature"] = temperature
-
-        if top_p is not None:
-            payload["top_p"] = top_p
-
-        # Add any additional parameters
-        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,
-                json=payload,
-                stream=True,
-                timeout=self._client.timeout
-            )
-
-            # Handle non-200 responses
-            if not response.ok:
-                raise IOError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
-                )
-
-            # Track token usage across chunks
-            prompt_tokens = 0
-            completion_tokens = 0
-            total_tokens = 0
-
-            # Estimate prompt tokens based on message length
-            for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
-
-            for line in response.iter_lines():
-                if line:
-                    decoded_line = line.decode('utf-8').strip()
-
-                    # WiseCat uses a different format, so we need to extract the content
-                    match = re.search(r'0:"(.*?)"', decoded_line)
-                    if match:
-                        content = match.group(1)
-
-                        # Format the content (replace escaped newlines)
-                        content = self._client.format_text(content)
-
-                        # Update token counts
-                        completion_tokens += 1
-                        total_tokens = prompt_tokens + completion_tokens
-
-                        # Create the delta object
-                        delta = ChoiceDelta(
-                            content=content,
-                            role="assistant",
-                            tool_calls=None
-                        )
-
-                        # Create the choice object
-                        choice = Choice(
-                            index=0,
-                            delta=delta,
-                            finish_reason=None,
-                            logprobs=None
-                        )
-
-                        # Create the chunk object
-                        chunk = ChatCompletionChunk(
-                            id=request_id,
-                            choices=[choice],
-                            created=created_time,
-                            model=model,
-                            system_fingerprint=None
-                        )
-
-                        # Convert to dict for proper formatting
-                        chunk_dict = chunk.to_dict()
-
-                        # Add usage information to match OpenAI format
-                        usage_dict = {
-                            "prompt_tokens": prompt_tokens,
-                            "completion_tokens": completion_tokens,
-                            "total_tokens": total_tokens,
-                            "estimated_cost": None
-                        }
-
-                        chunk_dict["usage"] = usage_dict
-
-                        # Return the chunk object for internal processing
-                        yield chunk
-
-            # Final chunk with finish_reason="stop"
-            delta = ChoiceDelta(
-                content=None,
-                role=None,
-                tool_calls=None
-            )
-
-            choice = Choice(
-                index=0,
-                delta=delta,
-                finish_reason="stop",
-                logprobs=None
-            )
-
-            chunk = ChatCompletionChunk(
-                id=request_id,
-                choices=[choice],
-                created=created_time,
-                model=model,
-                system_fingerprint=None
-            )
-
-            chunk_dict = chunk.to_dict()
-            chunk_dict["usage"] = {
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": total_tokens,
-                "estimated_cost": None
-            }
-
-            yield chunk
-
-        except Exception as e:
-            print(f"Error during WiseCat stream request: {e}")
-            raise IOError(f"WiseCat request failed: {e}") from e
-
-    def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
-    ) -> ChatCompletion:
-        try:
-            # For non-streaming, we still use streaming internally to collect the full response
-            response = self._client.session.post(
-                self._client.api_endpoint,
-                headers=self._client.headers,
-                json=payload,
-                stream=True,
-                timeout=self._client.timeout
-            )
-
-            # Handle non-200 responses
-            if not response.ok:
-                raise IOError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
-                )
-
-            # Collect the full response
-            full_text = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        full_text += content
-
-            # Format the text (replace escaped newlines)
-            full_text = self._client.format_text(full_text)
-
-            # Estimate token counts
-            prompt_tokens = 0
-            for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
-
-            completion_tokens = len(full_text.split())
-            total_tokens = prompt_tokens + completion_tokens
-
-            # Create the message object
-            message = ChatCompletionMessage(
-                role="assistant",
-                content=full_text
-            )
-
-            # Create the choice object
-            choice = Choice(
-                index=0,
-                message=message,
-                finish_reason="stop"
-            )
-
-            # Create the usage object
-            usage = CompletionUsage(
-                prompt_tokens=prompt_tokens,
-                completion_tokens=completion_tokens,
-                total_tokens=total_tokens
-            )
-
-            # Create the completion object
-            completion = ChatCompletion(
-                id=request_id,
-                choices=[choice],
-                created=created_time,
-                model=model,
-                usage=usage,
-            )
-
-            return completion
-
-        except Exception as e:
-            print(f"Error during WiseCat non-stream request: {e}")
-            raise IOError(f"WiseCat request failed: {e}") from e
-
-class Chat(BaseChat):
-    def __init__(self, client: 'WiseCat'):
-        self.completions = Completions(client)
-
-class WiseCat(OpenAICompatibleProvider):
-    """
-    OpenAI-compatible client for WiseCat API.
-
-    Usage:
-        client = WiseCat()
-        response = client.chat.completions.create(
-            model="chat-model-large",
-            messages=[{"role": "user", "content": "Hello!"}]
-        )
-    """
-
-    AVAILABLE_MODELS = [
-        "chat-model-small",
-        "chat-model-large",
-        "chat-model-reasoning",
-    ]
-
-    # No model mapping needed as we use the model names directly
-
-    def __init__(
-        self,
-        timeout: Optional[int] = None,
-        browser: str = "chrome"
-    ):
-        """
-        Initialize the WiseCat client.
-
-        Args:
-            timeout: Request timeout in seconds (None for no timeout)
-            browser: Browser to emulate in user agent
-        """
-        self.timeout = timeout
-        self.api_endpoint = "https://wise-cat-groq.vercel.app/api/chat"
-        self.session = requests.Session()
-
-        # Initialize LitAgent for user agent generation
-        agent = LitAgent()
-        self.fingerprint = agent.generate_fingerprint(browser)
-
-        # Use the fingerprint for headers
-        self.headers = self.fingerprint
-
-        self.session.headers.update(self.headers)
-
-        # Initialize the chat interface
-        self.chat = Chat(self)
-
-    def format_text(self, text: str) -> str:
-        """
-        Format text by replacing escaped newlines with actual newlines.
-
-        Args:
-            text: Text to format
-
-        Returns:
-            Formatted text
-        """
-        # Use a more comprehensive approach to handle all escape sequences
-        try:
-            # First handle double backslashes to avoid issues
-            text = text.replace('\\\\', '\\')
-
-            # Handle common escape sequences
-            text = text.replace('\\n', '\n')
-            text = text.replace('\\r', '\r')
-            text = text.replace('\\t', '\t')
-            text = text.replace('\\"', '"')
-            text = text.replace("\\'", "'")
-
-            # Handle any remaining escape sequences using JSON decoding
-            # This is a fallback in case there are other escape sequences
-            try:
-                # Add quotes to make it a valid JSON string
-                json_str = f'"{text}"'
-                # Use json module to decode all escape sequences
-                decoded = json.loads(json_str)
-                return decoded
-            except json.JSONDecodeError:
-                # If JSON decoding fails, return the text with the replacements we've already done
-                return text
-        except Exception as e:
-            # If any error occurs, return the original text
-            print(f"Warning: Error formatting text: {e}")
-            return text
-
-    def convert_model_name(self, model: str) -> str:
-        """
-        Convert model names to ones supported by WiseCat.
-
-        Args:
-            model: Model name to convert
-
-        Returns:
-            WiseCat model name
-        """
-        # If the model is already a valid WiseCat model, return it
-        if model in self.AVAILABLE_MODELS:
-            return model
-
-        # Default to the most capable model
-        print(f"Warning: Unknown model '{model}'. Using 'chat-model-large' instead.")
-        return "chat-model-large"

webscout/Provider/OPENAI/writecream.py

@@ -1,156 +0,0 @@
-import time
-import uuid
-import requests
-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
-)
-
-# Attempt to import LitAgent, fallback if not available
-try:
-    from webscout.litagent import LitAgent
-except ImportError:
-    print("Warning: LitAgent not found. Using default user agent.")
-
-class Completions(BaseCompletions):
-    def __init__(self, client: 'Writecream'):
-        self._client = client
-
-    def create(
-        *,
-        self,
-        model: str = None,  # Not used by Writecream, for compatibility
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = None,  # Not used by Writecream
-        stream: bool = False,
-        temperature: Optional[float] = None,  # Not used by Writecream
-        top_p: Optional[float] = None,  # Not used by Writecream
-        **kwargs: Any
-    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a model response for the given chat conversation.
-        Mimics openai.chat.completions.create
-        """
-        payload = messages
-        request_id = f"chatcmpl-{uuid.uuid4()}"
-        created_time = int(time.time())
-        if stream:
-            return self._create_stream(request_id, created_time, payload)
-        else:
-            return self._create_non_stream(request_id, created_time, payload)
-
-    def _create_stream(
-        self, request_id: str, created_time: int, payload: List[Dict[str, str]]
-    ) -> Generator[ChatCompletionChunk, None, None]:
-        # Writecream does not support streaming, so yield the full response as a single chunk
-        completion = self._create_non_stream(request_id, created_time, payload)
-        content = completion.choices[0].message.content
-        # Yield as a single chunk
-        delta = ChoiceDelta(content=content)
-        choice = Choice(index=0, delta=delta, finish_reason=None)
-        chunk = ChatCompletionChunk(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model="writecream",
-        )
-        yield chunk
-        # Final chunk with finish_reason
-        delta = ChoiceDelta(content=None)
-        choice = Choice(index=0, delta=delta, finish_reason="stop")
-        chunk = ChatCompletionChunk(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model="writecream",
-        )
-        yield chunk
-
-    def _create_non_stream(
-        self, request_id: str, created_time: int, payload: List[Dict[str, str]]
-    ) -> ChatCompletion:
-        try:
-            params = {
-                "query": json.dumps(payload),
-                "link": "writecream.com"
-            }
-            response = self._client.session.get(
-                self._client.base_url,
-                params=params,
-                headers=self._client.headers,
-                timeout=self._client.timeout
-            )
-            response.raise_for_status()
-            data = response.json()
-            # Extract the response content according to the new API format
-            content = data.get("response_content", "")
-            # Estimate tokens
-            prompt_tokens = sum(len(m.get("content", "").split()) for m in payload)
-            completion_tokens = len(content.split())
-            usage = CompletionUsage(
-                prompt_tokens=prompt_tokens,
-                completion_tokens=completion_tokens,
-                total_tokens=prompt_tokens + completion_tokens
-            )
-            message = ChatCompletionMessage(role="assistant", content=content)
-            choice = Choice(index=0, message=message, finish_reason="stop")
-            completion = ChatCompletion(
-                id=request_id,
-                choices=[choice],
-                created=created_time,
-                model="writecream",
-                usage=usage
-            )
-            return completion
-        except Exception as e:
-            print(f"Error during Writecream request: {e}")
-            raise IOError(f"Writecream request failed: {e}") from e
-
-class Chat(BaseChat):
-    def __init__(self, client: 'Writecream'):
-        self.completions = Completions(client)
-
-class Writecream(OpenAICompatibleProvider):
-    """
-    OpenAI-compatible client for Writecream API.
-
-    Usage:
-        client = Writecream()
-        response = client.chat.completions.create(
-            messages=[{"role": "system", "content": "You are a helpful assistant."},
-                      {"role": "user", "content": "What is the capital of France?"}]
-        )
-        print(response.choices[0].message.content)
-    """
-    AVAILABLE_MODELS = ["writecream"]
-
-    def __init__(self, timeout: Optional[int] = 30, browser: str = "chrome"):
-        self.timeout = timeout
-        self.base_url = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat"
-        self.session = requests.Session()
-        agent = LitAgent()
-        self.headers = {
-            "User-Agent": agent.random(),
-            "Referer": "https://www.writecream.com/chatgpt-chat/"
-        }
-        self.session.headers.update(self.headers)
-        self.chat = Chat(self)
-
-    def convert_model_name(self, model: str) -> str:
-        return "writecream"
-
-# Simple test if run directly
-if __name__ == "__main__":
-    client = Writecream()
-    response = client.chat.completions.create(
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "What is the capital of France?"}
-        ]
-    )
-    print(response.choices[0].message.content)