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

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
@@ -31,26 +28,20 @@ from .turboseek import *
 from .Free2GPT import *
 from .TeachAnything import *
 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 *
 from .geminiprorealtime import *
 from .llmchat import *
 from .llmchatco import LLMChatCo  # Add new LLMChat.co provider
 from .talkai import *
-from .askmyai import *
 from .llama3mitril import *
 from .Marcus import *
 from .typegpt import *
@@ -64,7 +55,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 +66,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 +83,17 @@ from .Writecream import Writecream
 from .toolbaz import Toolbaz
 from .scnet import SCNet
 from .WritingMate import WritingMate
+from .MCPCore import MCPCore
+from .TypliAI import TypliAI
+from .ChatSandbox import ChatSandbox
+from .GizAI import GizAI
 __all__ = [
-    'LLAMA',
     'SCNet',
+    'GizAI',
+    'ChatSandbox',
     'SciraAI',
     'StandardInputAI',
-    'LabyrinthAI',
     'OpenGPT',
-    'C4ai',
     'Venice',
     'ExaAI',
     'Copilot',
@@ -113,7 +103,6 @@ __all__ = [
     'AllenAI',
     'PerplexityLabs',
     'AkashGPT',
-    'DeepSeek',
     'WritingMate',
     'WiseCat',
     'IBMGranite',
@@ -131,18 +120,15 @@ __all__ = [
     'KOBOLDAI',
     'AsyncKOBOLDAI',
     'BLACKBOXAI',
-    'PhindSearch',
     'GEMINI',
     'DeepInfra',
     'AI4Chat',
-    'Phindv2',
     'OLLAMA',
     'AndiSearch',
     'PIZZAGPT',
     'Sambanova',
     'KOALA',
     'Meta',
-    'AskMyAI',
     'PiAI',
     'Julius',
     'YouChat',
@@ -151,10 +137,8 @@ __all__ = [
     'TurboSeek',
     'TeachAnything',
     'AI21',
-    'Chatify',
     'X0GPT',
     'Cerebras',
-    'Lepton',
     'GEMINIAPI',
     'SonusAI',
     'Cleeai',
@@ -164,13 +148,10 @@ __all__ = [
     'Free2GPT',
     'GPTWeb',
     'Netwrck',
-    'LlamaTutor',
     'PromptRefine',
     'TutorAI',
-    'ChatGPTES',
     'Bagoodex',
     'AIMathGPT',
-    'GaurishCerebras',
     'GeminiPro',
     'LLMChat',
     'LLMChatCo',
@@ -187,12 +168,13 @@ __all__ = [
     'ElectronHub',
     'GithubChat',
     'UncovrAI',
-    'WebSim',
     'VercelAI',
     'ExaChat',
     'AskSteve',
     'Aitopia',
     'SearchChatAI',
     'Writecream',
-    'Toolbaz'
+    'Toolbaz',
+    'MCPCore',
+    'TypliAI',
 ]

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/asksteve.py

@@ -1,8 +1,11 @@
-import requests
+from typing import Any, Dict, Optional, Union
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
+from webscout import exceptions
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
-from webscout.AIbase import Provider
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
+from webscout.AIbase import Provider 
 from webscout.litagent import LitAgent
 
 class AskSteve(Provider):
@@ -36,7 +39,7 @@ class AskSteve(Provider):
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
             system_prompt (str, optional): System prompt for AskSteve. Defaults to the provided string.
         """
-        self.session = requests.Session()
+        self.session = Session() # Use curl_cffi Session
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://quickstart.asksteve.to/quickStartRequest"
@@ -73,7 +76,15 @@ class AskSteve(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+        self.session.proxies = proxies # Assign proxies directly
+    @staticmethod
+    def _asksteve_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from AskSteve JSON response."""
+        if isinstance(chunk, dict) and "candidates" in chunk and len(chunk["candidates"]) > 0:
+            parts = chunk["candidates"][0].get("content", {}).get("parts", [])
+            if parts and isinstance(parts[0].get("text"), str):
+                return parts[0]["text"]
+        return None
 
     def ask(
         self,
@@ -115,37 +126,43 @@ class AskSteve(Provider):
             "prompt": conversation_prompt
         }
 
-        def for_stream():
+
+        # This API doesn't stream, so we process the full response
+        try:
             response = self.session.post(
                 self.api_endpoint,
                 headers=self.headers,
                 json=payload,
-                stream=True,
+                stream=False, # API doesn't stream
                 timeout=self.timeout,
+                impersonate="chrome120" # Add impersonate
             )
-            if not response.ok:
-                raise Exception(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
-                )
-            
-            response_data = response.json()
-            if "candidates" in response_data and len(response_data["candidates"]) > 0:
-                text = response_data["candidates"][0]["content"]["parts"][0]["text"]
-                self.last_response.update(dict(text=text))
-                yield dict(text=text) if not raw else text
-            else:
-                raise Exception("No response generated")
+            response.raise_for_status()
+            response_text_raw = response.text # Get raw text
+
+            # Process the full JSON text using sanitize_stream
+            processed_stream = sanitize_stream(
+                data=response_text_raw,
+                to_json=True, # Parse the whole text as JSON
+                intro_value=None,
+                content_extractor=self._asksteve_extractor, # Use the specific extractor
+                yield_raw_on_error=False
+            )
+            # Extract the single result
+            text = next(processed_stream, None)
+            text = text if isinstance(text, str) else "" # Ensure it's a string
 
+            self.last_response.update(dict(text=text))
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
+            # Return dict or raw string based on raw flag
+            return text if raw else self.last_response
 
-        def for_non_stream():
-            for _ in for_stream():
-                pass
-            return self.last_response
-
-        return for_stream() if stream else for_non_stream()
+        except CurlError as e:
+            raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+        except Exception as e: # Catch other potential errors
+            raise exceptions.FailedToGenerateResponseError(f"Failed to get response ({type(e).__name__}): {e}") from e
 
     def chat(
         self,
@@ -164,23 +181,15 @@ class AskSteve(Provider):
             str: Response generated
         """
 
-        def for_stream():
-            for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
-            ):
-                yield self.get_message(response)
-
-        def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
-            )
-
-        return for_stream() if stream else for_non_stream()
+        # Since ask() doesn't truly stream, we just call it once.
+        response_data = self.ask(
+            prompt,
+            stream=False, # Always False for this API
+            raw=False,    # Get the dict back
+            optimizer=optimizer,
+            conversationally=conversationally,
+        )
+        return self.get_message(response_data)
 
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response
@@ -192,12 +201,12 @@ class AskSteve(Provider):
             str: Message extracted
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        return response.get("text", "") # Use .get for safety
 
 
 if __name__ == "__main__":
     from rich import print
     ai = AskSteve()
-    response = ai.chat("hi", stream=True)
+    response = ai.chat("write a short poem about AI", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)