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

webscout/Provider/Writecream.py

@@ -1,10 +1,11 @@
-import requests
+from curl_cffi import CurlError 
+from curl_cffi.requests import Session # Keep Session import
 import json
 from typing import Any, Dict, Optional, Generator, Union
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -29,7 +30,6 @@ class Writecream(Provider):
         act: str = None,
         system_prompt: str = "You are a helpful and informative AI assistant.",
         base_url: str = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat",
-        user_agent: str = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Mobile Safari/537.36",
         referer: str = "https://www.writecream.com/chatgpt-chat/",
         link: str = "writecream.com",
         model: str = "writecream-gpt"
@@ -40,7 +40,8 @@ class Writecream(Provider):
         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.base_url = base_url
@@ -48,13 +49,16 @@ class Writecream(Provider):
         self.last_response = {}
         self.system_prompt = system_prompt
         self.model = model
-        self.user_agent = user_agent
+        # Initialize LitAgent
+        self.agent = LitAgent()
         self.referer = referer
         self.link = link
 
         self.headers = {
-            "User-Agent": self.user_agent,
+            # Use LitAgent for User-Agent
+            "User-Agent": self.agent.random(),
             "Referer": self.referer
+            # Add other headers if needed by curl_cffi impersonation or API
         }
 
         self.__available_optimizers = (
@@ -63,6 +67,7 @@ class Writecream(Provider):
             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.update(proxies)
 
@@ -123,20 +128,40 @@ class Writecream(Provider):
 
         def for_non_stream():
             try:
-                response = self.session.get(self.base_url, params=params, timeout=self.timeout)
+                # Use curl_cffi session.get with impersonate
+                response = self.session.get(
+                    self.base_url,
+                    params=params,
+                    timeout=self.timeout,
+                    impersonate="chrome120" # Add impersonate
+                )
                 response.raise_for_status()
-                data = response.json()
+                response_text = response.text # Get the raw text
+
+                # Use sanitize_stream to process the non-streaming text
+                # It will try to parse the whole text as JSON because to_json=True
+                processed_stream = sanitize_stream(
+                    data=response_text,
+                    to_json=True, # Attempt to parse the whole response text as JSON
+                    intro_value=None, # No prefix expected on the full response
+                    content_extractor=lambda chunk: chunk.get("response", chunk.get("response_content", "")) if isinstance(chunk, dict) else None
+                )
 
-                # Extract the response content
-                response_content = data.get("response", data.get("response_content", ""))
+                # Extract the single result from the generator
+                response_content = ""
+                for content in processed_stream:
+                    response_content = content if isinstance(content, str) else ""
 
                 # Update conversation history
                 self.last_response = {"text": response_content}
                 self.conversation.update_chat_history(prompt, response_content)
 
                 return {"text": response_content}
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Failed to get response from the chat API: {e}")
+                # Include original exception type
+                raise exceptions.FailedToGenerateResponseError(f"Failed to get response ({type(e).__name__}): {e}")
 
         # Currently, Writecream API doesn't support streaming, so we always return non-streaming response
         return for_non_stream()
@@ -188,6 +213,7 @@ class Writecream(Provider):
 
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<30} {'Status':<10} {'Response'}")
     print("-" * 80)

webscout/Provider/WritingMate.py

@@ -1,7 +1,9 @@
 import re
-import requests, json
+import json
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 from typing import Union, Any, Dict, Generator, Optional
-from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
+from webscout.AIutel import Optimizers, Conversation, AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -29,27 +31,34 @@ class WritingMate(Provider):
         intro: str = None,
         filepath: str = None,
         update_file: bool = True,
+        proxies: dict = {}, # Added proxies parameter
+        history_offset: int = 10250, # Added history_offset parameter
         act: str = None,
         system_prompt: str = "You are a friendly, helpful AI assistant.",
         model: str = "gpt-4o-mini"
     ):
         self.cookies_path = cookies_path
-        self.cookies = self._load_cookies(cookies_path)
-        self.session = requests.Session()
+        # Load cookies into a dictionary for curl_cffi
+        self.cookies = self._load_cookies_dict(cookies_path) 
+        # Initialize curl_cffi Session
+        self.session = Session() 
         self.timeout = timeout
         self.system_prompt = system_prompt
         self.model = model
         if self.model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Unknown model: {self.model}. Choose from {self.AVAILABLE_MODELS}")
         self.last_response = {}
+        self.agent = LitAgent() # Initialize LitAgent
         self.headers = {
             "Accept": "*/*",
             "Accept-Encoding": "gzip, deflate, br, zstd",
             "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "Content-Type": "text/plain;charset=UTF-8",
+            # Content-Type might be application/json based on body, but API expects text/plain? Keep for now.
+            "Content-Type": "text/plain;charset=UTF-8", 
             "Origin": "https://chat.writingmate.ai",
             "Referer": "https://chat.writingmate.ai/chat",
-            "Cookie": self.cookies,
+            # Remove Cookie header, pass cookies via parameter
+            # "Cookie": self.cookies, 
             "DNT": "1",
             "sec-ch-ua": "\"Microsoft Edge\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"",
             "sec-ch-ua-mobile": "?0",
@@ -58,9 +67,12 @@ class WritingMate(Provider):
             "Sec-Fetch-Mode": "cors",
             "Sec-Fetch-Site": "same-origin",
             "Sec-GPC": "1",
-            "User-Agent": LitAgent().random()
+            "User-Agent": self.agent.random() # Use LitAgent
         }
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies 
+        
         self.__available_optimizers = (
             m for m in dir(Optimizers)
             if callable(getattr(Optimizers, m)) and not m.startswith("__")
@@ -70,25 +82,51 @@ class WritingMate(Provider):
             if act else intro or Conversation.intro
         )
         self.conversation = Conversation(is_conversation, max_tokens, filepath, update_file)
-        self.conversation.history_offset = 10250
+        # Apply history offset
+        self.conversation.history_offset = history_offset 
 
-    def _load_cookies(self, path: str) -> str:
+    # Keep original _load_cookies if needed elsewhere, or remove
+    # def _load_cookies(self, path: str) -> str:
+    #     try:
+    #         with open(path, 'r') as f:
+    #             data = json.load(f)
+    #         return '; '.join(f"{c['name']}={c['value']}" for c in data)
+    #     except (FileNotFoundError, json.JSONDecodeError):
+    #         raise RuntimeError(f"Failed to load cookies from {path}")
+
+    # New method to load cookies as a dictionary
+    def _load_cookies_dict(self, path: str) -> Dict[str, str]:
         try:
             with open(path, 'r') as f:
                 data = json.load(f)
-            return '; '.join(f"{c['name']}={c['value']}" for c in data)
-        except (FileNotFoundError, json.JSONDecodeError):
-            raise RuntimeError(f"Failed to load cookies from {path}")
+            # Ensure data is a list of cookie objects
+            if not isinstance(data, list):
+                 raise ValueError("Cookie file should contain a list of cookie objects.")
+            return {c['name']: c['value'] for c in data if 'name' in c and 'value' in c}
+        except (FileNotFoundError, json.JSONDecodeError, ValueError) as e:
+            raise RuntimeError(f"Failed to load cookies from {path}: {e}")
 
+    @staticmethod
+    def _writingmate_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the WritingMate stream format '0:"..."'."""
+        if isinstance(chunk, str):
+            # Regex to find the pattern 0:"<content>"
+            match = re.search(r'0:"(.*?)"(?=,|$)', chunk) # Look for 0:"...", possibly followed by comma or end of string
+            if match:
+                # Decode potential unicode escapes like \u00e9 and handle escaped quotes/backslashes
+                content = match.group(1).encode().decode('unicode_escape')
+                return content.replace('\\\\', '\\').replace('\\"', '"')
+        return None
 
     def ask(
         self,
         prompt: str,
-        stream: bool = True,
+        stream: bool = True, # Defaulting stream to True as per original
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False
     ) -> Union[Dict[str,Any], Generator[Any,None,None]]:
+        # ... existing prompt generation and optimizer logic ...
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
@@ -96,8 +134,10 @@ class WritingMate(Provider):
                     conversation_prompt if conversationally else prompt
                 )
             else:
+                # Use the correct exception type
                 raise exceptions.FailedToGenerateResponseError(f"Unknown optimizer: {optimizer}")
 
+        # Body seems to be JSON, let curl_cffi handle serialization
         body = {
             "chatSettings": {
                 "model": self.model,
@@ -116,82 +156,114 @@ class WritingMate(Provider):
         }
 
         def for_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, json=body, 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:
+                # Use curl_cffi session post, pass cookies dict
+                response = self.session.post(
+                    self.api_endpoint, 
+                    headers=self.headers, 
+                    cookies=self.cookies, # Pass cookies dict
+                    json=body, # Pass body as json
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome120" # Add impersonate
+                    # http_version=CurlHttpVersion.V1_1 # Add if HTTP/2 errors occur
                 )
-            streaming_response = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        streaming_response += content
-                        yield content if raw else dict(text=content)
-            self.last_response.update(dict(text=streaming_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+                streaming_text = ""
+                # Use sanitize_stream with the custom extractor
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value=None, # No simple prefix
+                    to_json=False,    # Content is not JSON
+                    content_extractor=self._writingmate_extractor # Use the specific extractor
+                )
+
+                for content_chunk in processed_stream:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        yield content_chunk if raw else dict(text=content_chunk)
+
+                self.last_response.update(dict(text=streaming_text))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
 
         def for_non_stream():
+            # This function implicitly uses the updated for_stream
             for _ in for_stream():
                 pass
             return self.last_response
 
-        return for_stream() if stream else for_non_stream()
+        # Ensure stream defaults to True if not provided, matching original behavior
+        effective_stream = stream if stream is not None else True 
+        return for_stream() if effective_stream else for_non_stream()
 
     def chat(
         self,
         prompt: str,
-        stream: bool = False,
+        stream: bool = False, # Default stream to False as per original chat method
         optimizer: str = None,
         conversationally: bool = False
     ) -> Union[str, Generator[str,None,None]]:
         if stream:
-            # yield raw SSE lines
-            def raw_stream():
-                for line in self.ask(
-                    prompt, stream=True, raw=True,
+            # yield decoded text chunks
+            def text_stream():
+                # Call ask with stream=True, raw=False to get dicts
+                for response_dict in self.ask(
+                    prompt, stream=True, raw=False,
                     optimizer=optimizer, conversationally=conversationally
                 ):
-                    yield line
-            return raw_stream()
-        # non‐stream: return aggregated text
-        return self.get_message(
-            self.ask(
+                    # Extract text from dict
+                    yield self.get_message(response_dict) 
+            return text_stream()
+        else: # non‐stream: return aggregated text
+            # Call ask with stream=False, raw=False
+            response_data = self.ask(
                 prompt,
-                False,
+                stream=False,
                 raw=False,
                 optimizer=optimizer,
                 conversationally=conversationally,
             )
-        )
-
-    def get_message(self, response: dict) -> str:
-        """
-        Extracts the message from the API response.
-
-        Args:
-            response (dict): The API response.
+            # Ensure response_data is a dict before passing to get_message
+            if isinstance(response_data, dict):
+                 return self.get_message(response_data)
+            else:
+                 # Handle unexpected generator case if ask(stream=False) behaves differently
+                 # This part might need adjustment based on actual behavior
+                 full_text = "".join(self.get_message(chunk) for chunk in response_data if isinstance(chunk, dict))
+                 return full_text
 
-        Returns:
-            str: The message content.
 
-        Examples:
-            >>> ai = X0GPT()
-            >>> response = ai.ask("Tell me a joke!")
-            >>> message = ai.get_message(response)
-            >>> print(message)
-            'Why did the scarecrow win an award? Because he was outstanding in his field!'
-        """
+    def get_message(self, response: dict) -> str:
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        formatted_text = response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        # Ensure text exists before processing
+        # Formatting is now mostly handled by the extractor
+        text = response.get("text", "") 
+        formatted_text = text # Keep newline replacement if needed: .replace('\\n', '\n')
         return formatted_text
     
 if __name__ == "__main__":
     from rich import print
-    ai = WritingMate(cookies_path="cookies.json")
-    response = ai.chat(input(">>> "), stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    try:
+        ai = WritingMate(cookies_path="cookies.json", proxies={}, timeout=120) # Example with proxies and timeout
+        # Get input within the try block
+        user_input = input(">>> ") 
+        response = ai.chat(user_input, stream=True)
+        print("[bold green]Assistant:[/bold green]")
+        for chunk in response:
+            print(chunk, end="", flush=True)
+        print() # Add a newline at the end
+    except RuntimeError as e:
+        print(f"[bold red]Error initializing WritingMate:[/bold red] {e}")
+    except exceptions.FailedToGenerateResponseError as e:
+        print(f"[bold red]Error during chat:[/bold red] {e}")
+    except Exception as e:
+        print(f"[bold red]An unexpected error occurred:[/bold red] {e}")

webscout/Provider/__init__.py

@@ -1,6 +1,5 @@
 # webscout/providers/__init__.py
 from .PI import *
-from .Llama import LLAMA
 from .Cohere import Cohere
 from .Reka import REKA
 from .Groq import GROQ
@@ -10,8 +9,6 @@ from .Openai import AsyncOPENAI
 from .Koboldai import KOBOLDAI
 from .Koboldai import AsyncKOBOLDAI
 from .Blackboxai import BLACKBOXAI
-from .Phind import PhindSearch
-from .Phind import Phindv2
 from .ai4chat import *
 from .Gemini import GEMINI
 from .Deepinfra import DeepInfra
@@ -34,15 +31,12 @@ from .AI21 import *
 from .Chatify import *
 from .x0gpt import *
 from .cerebras import *
-from .lepton import *
 from .geminiapi import *
 from .elmo import *
 from .GPTWeb import *
 from .Netwrck import Netwrck
-from .llamatutor import *
 from .promptrefine import *
 from .tutorai import *
-from .ChatGPTES import *
 from .bagoodex import *
 from .aimathgpt import *
 from .gaurish import *
@@ -64,7 +58,6 @@ from .ChatGPTGratis import *
 from .QwenLM import *
 from .granite import *
 from .WiseCat import *
-from .DeepSeek import *
 from .freeaichat import FreeAIChat
 from .akashgpt import *
 from .Perplexitylabs import *
@@ -76,11 +69,8 @@ from .ElectronHub import *
 from .HuggingFaceChat import *
 from .GithubChat import *
 from .copilot import *
-from .C4ai import *
 from .sonus import *
 from .uncovr import *
-from .labyrinth import *
-from .WebSim import *
 from .LambdaChat import *
 from .ChatGPTClone import *
 from .VercelAI import *
@@ -96,14 +86,12 @@ from .Writecream import Writecream
 from .toolbaz import Toolbaz
 from .scnet import SCNet
 from .WritingMate import WritingMate
+from .MCPCore import MCPCore
 __all__ = [
-    'LLAMA',
     'SCNet',
     'SciraAI',
     'StandardInputAI',
-    'LabyrinthAI',
     'OpenGPT',
-    'C4ai',
     'Venice',
     'ExaAI',
     'Copilot',
@@ -113,7 +101,6 @@ __all__ = [
     'AllenAI',
     'PerplexityLabs',
     'AkashGPT',
-    'DeepSeek',
     'WritingMate',
     'WiseCat',
     'IBMGranite',
@@ -131,11 +118,9 @@ __all__ = [
     'KOBOLDAI',
     'AsyncKOBOLDAI',
     'BLACKBOXAI',
-    'PhindSearch',
     'GEMINI',
     'DeepInfra',
     'AI4Chat',
-    'Phindv2',
     'OLLAMA',
     'AndiSearch',
     'PIZZAGPT',
@@ -154,7 +139,6 @@ __all__ = [
     'Chatify',
     'X0GPT',
     'Cerebras',
-    'Lepton',
     'GEMINIAPI',
     'SonusAI',
     'Cleeai',
@@ -164,10 +148,8 @@ __all__ = [
     'Free2GPT',
     'GPTWeb',
     'Netwrck',
-    'LlamaTutor',
     'PromptRefine',
     'TutorAI',
-    'ChatGPTES',
     'Bagoodex',
     'AIMathGPT',
     'GaurishCerebras',
@@ -187,12 +169,12 @@ __all__ = [
     'ElectronHub',
     'GithubChat',
     'UncovrAI',
-    'WebSim',
     'VercelAI',
     'ExaChat',
     'AskSteve',
     'Aitopia',
     'SearchChatAI',
     'Writecream',
-    'Toolbaz'
+    'Toolbaz',
+    'MCPCore'
 ]

webscout/Provider/ai4chat.py

@@ -1,4 +1,4 @@
-import requests
+from curl_cffi.requests import Session, RequestsError
 import urllib.parse
 from typing import Union, Any, Dict
 
@@ -44,7 +44,7 @@ class AI4Chat(Provider):
             country (str, optional): Country parameter for API. Defaults to "Asia".
             user_id (str, optional): User ID for API. Defaults to "usersmjb2oaz7y".
         """
-        self.session = requests.Session()
+        self.session = Session(timeout=timeout, proxies=proxies)
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://yw85opafq6.execute-api.us-east-1.amazonaws.com/default/boss_mode_15aug"
@@ -84,7 +84,6 @@ class AI4Chat(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
         self.system_prompt = system_prompt 
 
     def ask(
@@ -123,24 +122,24 @@ class AI4Chat(Provider):
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
 
-        # Use provided values or defaults
         country_param = country or self.country
         user_id_param = user_id or self.user_id
         
-        # Build the URL with parameters
         encoded_text = urllib.parse.quote(conversation_prompt)
         encoded_country = urllib.parse.quote(country_param)
         encoded_user_id = urllib.parse.quote(user_id_param)
         
         url = f"{self.api_endpoint}?text={encoded_text}&country={encoded_country}&user_id={encoded_user_id}"
         
-        response = self.session.get(url, headers=self.headers, timeout=self.timeout)
+        try:
+            response = self.session.get(url, headers=self.headers, timeout=self.timeout)
+        except RequestsError as e:
+            raise Exception(f"Failed to generate response: {e}")
         if not response.ok:
             raise Exception(f"Failed to generate response: {response.status_code} - {response.reason}")
         
         response_text = response.text
         
-        # Remove quotes from the start and end of the response
         if response_text.startswith('"'):
             response_text = response_text[1:]
         if response_text.endswith('"'):

webscout/Provider/copilot.py

@@ -2,7 +2,6 @@ import os
 import json
 import base64
 import asyncio
-import requests
 from urllib.parse import quote
 from typing import Optional, Dict, Any, List, Union, Generator
 
@@ -287,8 +286,6 @@ class Copilot(Provider):
                     finally:
                         wss.close()
                         
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Error: {str(e)}")