webscout 7.4__py3-none-any.whl → 7.6__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)}")