webscout 7.5__py3-none-any.whl → 7.7__py3-none-any.whl

webscout/Provider/TTS/streamElements.py

@@ -2,15 +2,14 @@ import time
 import requests
 import pathlib
 import urllib.parse
-from typing import Union, Generator
-from playsound import playsound
+import tempfile
+from typing import Union
+from io import BytesIO
 from webscout import exceptions
 from webscout.AIbase import TTSProvider
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent
-from . import utils
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from io import BytesIO
+from . import utils
 
 class StreamElements(TTSProvider): 
     """
@@ -21,7 +20,6 @@ class StreamElements(TTSProvider):
     headers: dict[str, str] = {
         "User-Agent": LitAgent().random()
     }
-    cache_dir = pathlib.Path("./audio_cache")
     all_voices: list[str] = [
         "Filiz",
         "Astrid",
@@ -238,11 +236,7 @@ class StreamElements(TTSProvider):
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
-        self.logger = Logger(
-            name="StreamElementsTTS",
-            format=LogFormat.MODERN_EMOJI,
-
-        )
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
 
     def tts(self, text: str, voice: str = "Mathieu", verbose: bool = True) -> str:
         """
@@ -260,7 +254,7 @@ class StreamElements(TTSProvider):
             voice in self.all_voices
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices)}]"
 
-        filename = self.cache_dir / f"{int(time.time())}.mp3"
+        filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
 
         # Split text into sentences
         sentences = utils.split_sentences(text)
@@ -278,20 +272,17 @@ class StreamElements(TTSProvider):
                     response = self.session.get(url, headers=self.headers, timeout=self.timeout)
                     response.raise_for_status()
 
-                    # Create the audio_cache directory if it doesn't exist
-                    self.cache_dir.mkdir(parents=True, exist_ok=True) 
-
                     # Check if the request was successful
                     if response.ok and response.status_code == 200:
                         if verbose:
-                            self.logger.success(f"Chunk {part_number} processed successfully 🎉")
+                            print(f"[debug] Chunk {part_number} processed successfully")
                         return part_number, response.content
                     else:
                         if verbose:
-                            self.logger.warning(f"No data received for chunk {part_number}. Retrying...")
+                            print(f"[debug] No data received for chunk {part_number}. Retrying...")
                 except requests.RequestException as e:
                     if verbose:
-                        self.logger.error(f"Error for chunk {part_number}: {e}. Retrying... 🔄")
+                        print(f"[debug] Error for chunk {part_number}: {e}. Retrying...")
                     time.sleep(1)
         try:
             # Using ThreadPoolExecutor to handle requests concurrently
@@ -309,52 +300,34 @@ class StreamElements(TTSProvider):
                         audio_chunks[part_number] = audio_data  # Store the audio data in correct sequence
                     except Exception as e:
                         if verbose:
-                            self.logger.error(f"Failed to generate audio for chunk {chunk_num}: {e} 🚨")
+                            print(f"[debug] Failed to generate audio for chunk {chunk_num}: {e}")
 
             # Combine audio chunks in the correct sequence
             combined_audio = BytesIO()
             for part_number in sorted(audio_chunks.keys()):
                 combined_audio.write(audio_chunks[part_number])
                 if verbose:
-                    self.logger.debug(f"Added chunk {part_number} to the combined file.")
+                    print(f"[debug] Added chunk {part_number} to the combined file.")
 
             # Save the combined audio data to a single file
             with open(filename, 'wb') as f:
                 f.write(combined_audio.getvalue())
             if verbose:
-                self.logger.info(f"Final Audio Saved as {filename} 🔊")
+                print(f"[debug] Final Audio Saved as {filename}")
             return filename.as_posix()
 
         except requests.exceptions.RequestException as e:
-            self.logger.critical(f"Failed to perform the operation: {e} 🚨")
+            if verbose:
+                print(f"[debug] Failed to perform the operation: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Failed to perform the operation: {e}"
             )
-        
-    def play_audio(self, filename: str):
-        """
-        Plays an audio file using playsound.
-
-        Args:
-            filename (str): The path to the audio file.
-
-        Raises:
-            RuntimeError: If there is an error playing the audio.
-        """
-        try:
-            self.logger.info(f"Playing audio: {filename} 🎵")
-            playsound(filename)
-        except Exception as e:
-            self.logger.error(f"Error playing audio: {e} 🔇")
-            raise RuntimeError(f"Error playing audio: {e}")
 
 # Example usage
 if __name__ == "__main__":
     streamelements = StreamElements()
     text = "This is a test of the StreamElements text-to-speech API. It supports multiple sentences and advanced logging."
 
-    streamelements.logger.info("Generating audio...")
-    audio_file = streamelements.tts(text, voice="Mathieu") 
-
-    streamelements.logger.info("Playing audio...")
-    streamelements.play_audio(audio_file)
+    print("[debug] Generating audio...")
+    audio_file = streamelements.tts(text, voice="Mathieu")
+    print(f"Audio saved to: {audio_file}")

webscout/Provider/TextPollinationsAI.py

@@ -4,11 +4,11 @@ from typing import Any, Dict, Generator
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
-from webscout.Litlogger import Logger, LogFormat
 from webscout import LitAgent as Lit
+
 class TextPollinationsAI(Provider):
     """
-    A class to interact with the Pollinations AI API with comprehensive logging.
+    A class to interact with the Pollinations AI API.
     """
 
     AVAILABLE_MODELS = [
@@ -23,21 +23,21 @@ class TextPollinationsAI(Provider):
         "rtist",               # Rtist image generator
         "searchgpt",           # SearchGPT with realtime search
         "evil",                # Evil Mode - Experimental
-        "deepseek",            # DeepSeek-V3
+        # "deepseek",            # DeepSeek-V3 >>>> NOT WORKING
         "claude-hybridspace",  # Claude Hybridspace
         "deepseek-r1",         # DeepSeek-R1 Distill Qwen 32B
-        "deepseek-reasoner",   # DeepSeek R1 - Full
-        "llamalight",          # Llama 3.1 8B Instruct
-        "llamaguard",          # Llamaguard 7B AWQ
+        # "deepseek-reasoner",   # DeepSeek R1 - Full >>>> NOT WORKING
+        # "llamalight",          # Llama 3.1 8B Instruct >>>> NOT WORKING
+        # "llamaguard",          # Llamaguard 7B AWQ >>>> NOT WORKING
         "gemini",              # Gemini 2.0 Flash
         "gemini-thinking",     # Gemini 2.0 Flash Thinking
         "hormoz",              # Hormoz 8b
         "hypnosis-tracy",      # Hypnosis Tracy
         "sur",                 # Sur AI Assistant
         "sur-mistral",         # Sur AI Assistant (Mistral)
-        "llama-scaleway",      # Llama (Scaleway)
+        # "llama-scaleway",      # Llama (Scaleway) >>>> NOT WORKING
         "phi",                 # Phi model
-        "openai-audio"         # OpenAI Audio model
+        # "openai-audio"         # OpenAI Audio model >>>> NOT WORKING
     ]
 
     def __init__(
@@ -53,20 +53,11 @@ class TextPollinationsAI(Provider):
         act: str = None,
         model: str = "openai-large",
         system_prompt: str = "You are a helpful AI assistant.",
-        logging: bool = False
     ):
-        """Initializes the TextPollinationsAI API client with logging capabilities."""
+        """Initializes the TextPollinationsAI API client."""
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
 
-        self.logger = Logger(
-            name="TextPollinationsAI",
-            format=LogFormat.MODERN_EMOJI,
-        ) if logging else None
-
-        if self.logger:
-            self.logger.info(f"Initializing TextPollinationsAI with model: {model}")
-
         self.session = requests.Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -105,9 +96,6 @@ class TextPollinationsAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-        if self.logger:
-            self.logger.info("TextPollinationsAI initialized successfully")
-
     def ask(
         self,
         prompt: str,
@@ -116,22 +104,14 @@ class TextPollinationsAI(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> Dict[str, Any] | Generator[Dict[str, Any], None, None]:
-        """Chat with AI with logging capabilities"""
-        if self.logger:
-            self.logger.debug(f"Processing request - Prompt: {prompt[:50]}...")
-            self.logger.debug(f"Stream: {stream}, Optimizer: {optimizer}")
-
+        """Chat with AI"""
         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
                 )
-                if self.logger:
-                    self.logger.debug(f"Applied optimizer: {optimizer}")
             else:
-                if self.logger:
-                    self.logger.error(f"Invalid optimizer requested: {optimizer}")
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
         payload = {
@@ -144,9 +124,6 @@ class TextPollinationsAI(Provider):
         }
 
         def for_stream():
-            if self.logger:
-                self.logger.debug("Initiating streaming request to API")
-
             response = self.session.post(
                 self.api_endpoint,
                 headers=self.headers,
@@ -156,22 +133,15 @@ class TextPollinationsAI(Provider):
             )
 
             if not response.ok:
-                if self.logger:
-                    self.logger.error(f"API request failed. Status: {response.status_code}, Reason: {response.reason}")
                 raise exceptions.FailedToGenerateResponseError(
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
 
-            if self.logger:
-                self.logger.info(f"API connection established successfully. Status: {response.status_code}")
-
             full_response = ""
             for line in response.iter_lines():
                 if line:
                     line = line.decode('utf-8').strip()
                     if line == "data: [DONE]":
-                        if self.logger:
-                            self.logger.debug("Stream completed")
                         break
                     if line.startswith('data: '):
                         try:
@@ -184,9 +154,7 @@ class TextPollinationsAI(Provider):
                                     content = ""
                                 full_response += content
                                 yield content if raw else dict(text=content)
-                        except json.JSONDecodeError as e:
-                            if self.logger:
-                                self.logger.error(f"JSON parsing error: {str(e)}")
+                        except json.JSONDecodeError:
                             continue
 
             self.last_response.update(dict(text=full_response))
@@ -194,12 +162,7 @@ class TextPollinationsAI(Provider):
                 prompt, self.get_message(self.last_response)
             )
 
-            if self.logger:
-                self.logger.debug("Response processing completed")
-
         def for_non_stream():
-            if self.logger:
-                self.logger.debug("Processing non-streaming request")
             for _ in for_stream():
                 pass
             return self.last_response
@@ -213,10 +176,7 @@ class TextPollinationsAI(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> str | Generator[str, None, None]:
-        """Generate response as a string with logging"""
-        if self.logger:
-            self.logger.debug(f"Chat request initiated - Prompt: {prompt[:50]}...")
-
+        """Generate response as a string"""
         def for_stream():
             for response in self.ask(
                 prompt, True, optimizer=optimizer, conversationally=conversationally
@@ -241,10 +201,30 @@ class TextPollinationsAI(Provider):
         return response["text"]
 
 if __name__ == "__main__":
-    from rich import print
-    # Enable logging for testing
-    ai = TextPollinationsAI(model="deepseek-r1", logging=True)
-    response = ai.chat(input(">>> "), stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
-
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+    
+    # Test all available models
+    working = 0
+    total = len(TextPollinationsAI.AVAILABLE_MODELS)
+    
+    for model in TextPollinationsAI.AVAILABLE_MODELS:
+        try:
+            test_ai = TextPollinationsAI(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/Venice.py

@@ -188,13 +188,30 @@ class Venice(Provider):
         return response["text"]
 
 if __name__ == "__main__":
-    from rich import print
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
     
-    # Initialize Venice AI
-    ai = Venice(model="qwen2dot5-coder-32b", timeout=50)
+    # Test all available models
+    working = 0
+    total = len(Venice.AVAILABLE_MODELS)
     
-    # Test chat with streaming
-    response = ai.chat("Write a short story about an AI assistant", stream=False)
-    print(response)
-    # for chunk in response:
-    #     print(chunk, end="", flush=True)
+    for model in Venice.AVAILABLE_MODELS:
+        try:
+            test_ai = Venice(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/WebSim.py

@@ -0,0 +1,227 @@
+import requests
+import json
+import string
+import random
+from typing import Any, Dict, Union
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider
+from webscout import exceptions
+
+class WebSim(Provider):
+    """
+    A class to interact with the WebSim API.
+    """
+
+    url = "https://websim.ai"
+    chat_api_endpoint = "https://websim.ai/api/v1/inference/run_chat_completion"
+    image_api_endpoint = "https://websim.ai/api/v1/inference/run_image_generation"
+
+    image_models = ['flux']
+    AVAILABLE_MODELS = ['gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-flash', 'gemini-pro', 'gemini-flash-thinking'] + image_models
+
+    @staticmethod
+    def generate_project_id(for_image=False):
+        """
+        Generate a project ID in the appropriate format
+        
+        For chat: format like 'ke3_xh5gai3gjkmruomu'
+        For image: format like 'kx0m131_rzz66qb2xoy7'
+        """
+        chars = string.ascii_lowercase + string.digits
+        
+        if for_image:
+            first_part = ''.join(random.choices(chars, k=7))
+            second_part = ''.join(random.choices(chars, k=12))
+            return f"{first_part}_{second_part}"
+        else:
+            prefix = ''.join(random.choices(chars, k=3))
+            suffix = ''.join(random.choices(chars, k=15))
+            return f"{prefix}_{suffix}"
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = 'gemini-1.5-pro',
+        aspect_ratio: str = "1:1"
+    ):
+        """Initializes the WebSim API client."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            
+        self.headers = {
+            'accept': '*/*',
+            'accept-language': 'en-US,en;q=0.9',
+            'content-type': 'text/plain;charset=UTF-8',
+            'origin': 'https://websim.ai',
+            'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            'websim-flags;': ''
+        }
+        
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.aspect_ratio = aspect_ratio
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Dict[str, Any]:
+        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}")
+
+        is_image_request = self.model in self.image_models
+        project_id = self.generate_project_id(for_image=is_image_request)
+
+        if is_image_request:
+            self.headers['referer'] = 'https://websim.ai/@ISWEARIAMNOTADDICTEDTOPILLOW/ai-image-prompt-generator'
+            return self._handle_image_request(project_id, conversation_prompt)
+        else:
+            self.headers['referer'] = 'https://websim.ai/@ISWEARIAMNOTADDICTEDTOPILLOW/zelos-ai-assistant'
+            return self._handle_chat_request(project_id, conversation_prompt)
+
+    def _handle_image_request(self, project_id: str, prompt: str) -> Dict[str, Any]:
+        try:
+            data = {
+                "project_id": project_id,
+                "prompt": prompt,
+                "aspect_ratio": self.aspect_ratio
+            }
+            response = self.session.post(
+                self.image_api_endpoint,
+                json=data,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            response_json = response.json()
+            image_url = response_json.get("url")
+            if image_url:
+                self.last_response = {"text": image_url}
+                self.conversation.update_chat_history(prompt, image_url)
+                return {"text": image_url}
+            raise exceptions.FailedToGenerateResponseError("No image URL found in response")
+        except requests.RequestException as e:
+            raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+
+    def _handle_chat_request(self, project_id: str, prompt: str) -> Dict[str, Any]:
+        max_retries = 3
+        retry_count = 0
+        last_error = None
+        
+        while retry_count < max_retries:
+            try:
+                data = {
+                    "project_id": project_id,
+                    "messages": [{"role": "user", "content": prompt}]
+                }
+                response = self.session.post(
+                    self.chat_api_endpoint,
+                    json=data,
+                    timeout=self.timeout
+                )
+                
+                if response.status_code == 429:
+                    last_error = exceptions.FailedToGenerateResponseError(
+                        f"Rate limit exceeded: {response.text}"
+                    )
+                    retry_count += 1
+                    if retry_count < max_retries:
+                        continue
+                    raise last_error
+                
+                response.raise_for_status()
+                response_json = response.json()
+                content = response_json.get("content", "")
+                
+                self.last_response = {"text": content}
+                self.conversation.update_chat_history(prompt, content)
+                return {"text": content.strip()}
+                
+            except requests.RequestException as e:
+                if "Rate limit exceeded" in str(e) and retry_count < max_retries:
+                    retry_count += 1
+                else:
+                    raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+        
+        raise last_error or exceptions.FailedToGenerateResponseError("Max retries exceeded")
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        return self.get_message(
+            self.ask(prompt, False, optimizer=optimizer, conversationally=conversationally)
+        )
+
+    def get_message(self, response: dict) -> str:
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+if __name__ == "__main__":
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in WebSim.AVAILABLE_MODELS:
+        try:
+            test_ai = WebSim(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word")
+            
+            if response and len(response.strip()) > 0:
+                status = "✓"
+                # Clean and truncate response
+                clean_text = response.strip().encode('utf-8', errors='ignore').decode('utf-8')
+                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}") 

webscout/Provider/WiseCat.py

@@ -169,8 +169,30 @@ class WiseCat(Provider):
         return response["text"]
 
 if __name__ == "__main__":
-    from rich import print
-    ai = WiseCat()
-    response = ai.chat(input(">>> "))
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+    
+    # Test all available models
+    working = 0
+    total = len(WiseCat.AVAILABLE_MODELS)
+    
+    for model in WiseCat.AVAILABLE_MODELS:
+        try:
+            test_ai = WiseCat(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")