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

webscout/AIauto.py

@@ -1,20 +1,11 @@
 from webscout.AIbase import Provider
-from webscout.g4f import GPT4FREE, TestProviders
 from webscout.exceptions import AllProvidersFailure
-from webscout.Litlogger import Litlogger, LogFormat, ColorScheme
 from typing import Union, Any, Dict, Generator
 import importlib
 import pkgutil
 import random
 import inspect
 
-# Initialize LitLogger with cyberpunk theme
-logger = Litlogger(
-    name="AIauto",
-    format=LogFormat.DETAILED,
-    color_scheme=ColorScheme.CYBERPUNK
-)
-
 def load_providers():
     provider_map = {}
     api_key_providers = set()
@@ -30,13 +21,8 @@ def load_providers():
                     # Check if the provider needs an API key
                     if 'api_key' in inspect.signature(attr.__init__).parameters:
                         api_key_providers.add(attr_name.upper())
-                        logger.debug(f"Provider {attr_name} requires API key")
-            logger.success(f"Loaded provider module: {module_name}")
-        except Exception as e:
-            logger.error(f"Failed to load provider {module_name}: {str(e)}")
-    
-    logger.info(f"Total providers loaded: {len(provider_map)}")
-    logger.info(f"API key providers: {len(api_key_providers)}")
+        except Exception:
+            pass
     return provider_map, api_key_providers
 
 provider_map, api_key_providers = load_providers()
@@ -106,7 +92,6 @@ class AUTO(Provider):
         for provider_name, provider_class in available_providers:
             try:
                 self.provider_name = f"webscout-{provider_name}"
-                logger.info(f"Trying provider: {self.provider_name}")
                 
                 self.provider = provider_class(
                     is_conversation=self.is_conversation,
@@ -120,44 +105,11 @@ class AUTO(Provider):
                     act=self.act,
                 )
                 response = self.provider.ask(**ask_kwargs)
-                logger.success(f"Successfully used provider: {self.provider_name}")
-                return response
-            except Exception as e:
-                logger.warning(f"Provider {self.provider_name} failed: {str(e)}")
-                continue
-
-        # Try GPT4FREE providers
-        gpt4free_providers = TestProviders(timeout=self.timeout).get_results(run=run_new_test)
-        random.shuffle(gpt4free_providers)
-        
-        for provider_info in gpt4free_providers:
-            if provider_info["name"].upper() in self.exclude:
-                continue
-            try:
-                self.provider_name = f"g4f-{provider_info['name']}"
-                logger.info(f"Trying provider: {self.provider_name}")
-                
-                self.provider = GPT4FREE(
-                    provider=provider_info["name"],
-                    is_conversation=self.is_conversation,
-                    max_tokens=self.max_tokens,
-                    intro=self.intro,
-                    filepath=self.filepath,
-                    update_file=self.update_file,
-                    proxies=self.proxies,
-                    history_offset=self.history_offset,
-                    act=self.act,
-                )
-
-                response = self.provider.ask(**ask_kwargs)
-                logger.success(f"Successfully used provider: {self.provider_name}")
                 return response
-            except Exception as e:
-                logger.warning(f"Provider {self.provider_name} failed: {str(e)}")
+            except Exception:
                 continue
 
         # If we get here, all providers failed
-        logger.error("All providers failed to process the request")
         raise AllProvidersFailure("All providers failed to process the request")
 
     def chat(
@@ -167,7 +119,7 @@ class AUTO(Provider):
         optimizer: str = None,
         conversationally: bool = False,
         run_new_test: bool = False,
-    ) -> Union[str, Generator[str, None, None]]:
+    ) -> Union[str, Generator[str, None, None]]: 
         response = self.ask(
             prompt,
             stream,
@@ -184,8 +136,8 @@ class AUTO(Provider):
     def get_message(self, response: dict) -> str:
         assert self.provider is not None, "Chat with AI first"
         return self.provider.get_message(response)
+    
 if __name__ == "__main__":
     auto = AUTO()
-
     response = auto.chat("Hello, how are you?")
     print(response)

webscout/AIutel.py

@@ -1,25 +1,8 @@
-import os
 import json
 import platform
 import subprocess
-import logging
-import threading
-import time
-import datetime
-import re
-import sys
-from rich.markdown import Markdown
-from rich.console import Console
-from typing import List, Tuple, Union
-from typing import NoReturn
-import requests
-from pathlib import Path
-from playsound import playsound
-from time import sleep as wait
-import pathlib
-import urllib.parse
 
-default_path = os.path.join(os.path.expanduser("~"), ".cache", "AIWEBS", "webscout")
+
 
 def sanitize_stream(
     chunk: str, intro_value: str = "data:", to_json: bool = True
@@ -39,6 +22,7 @@ def sanitize_stream(
         chunk = chunk[len(intro_value) :]
 
     return json.loads(chunk) if to_json else chunk
+
 def run_system_command(
     command: str,
     exit_on_error: bool = True,
@@ -50,9 +34,9 @@ def run_system_command(
         command (str): shell command
         exit_on_error (bool, optional): Exit on error. Defaults to True.
         stdout_error (bool, optional): Print out the error. Defaults to True
-        help (str, optional): Help info incase of exception. Defaults to None.
+        help (str, optional): Help info in case of exception. Defaults to None.
     Returns:
-        tuple : (is_successfull, object[Exception|Subprocess.run])
+        tuple : (is_successful, object[Exception|Subprocess.run])
     """
     try:
         # Run the command and capture the output
@@ -71,15 +55,6 @@ def run_system_command(
         else:
             return (False, e)  
 
-
-from .conversation import Conversation
-
-from .optimizers import Optimizers
-
-from .Extra.autocoder import AutoCoder
-
-from .prompt_manager import AwesomePrompts
-
 class Updates:
     """Webscout latest release info"""
 
@@ -147,295 +122,10 @@ class Updates:
 
             return sorted
 
+from .conversation import Conversation
 
-class Audio:
-    # Request headers
-    headers: dict[str, str] = {
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
-    }
-    cache_dir = pathlib.Path("./audio_cache")
-    all_voices: list[str] = [
-        "Filiz",
-        "Astrid",
-        "Tatyana",
-        "Maxim",
-        "Carmen",
-        "Ines",
-        "Cristiano",
-        "Vitoria",
-        "Ricardo",
-        "Maja",
-        "Jan",
-        "Jacek",
-        "Ewa",
-        "Ruben",
-        "Lotte",
-        "Liv",
-        "Seoyeon",
-        "Takumi",
-        "Mizuki",
-        "Giorgio",
-        "Carla",
-        "Bianca",
-        "Karl",
-        "Dora",
-        "Mathieu",
-        "Celine",
-        "Chantal",
-        "Penelope",
-        "Miguel",
-        "Mia",
-        "Enrique",
-        "Conchita",
-        "Geraint",
-        "Salli",
-        "Matthew",
-        "Kimberly",
-        "Kendra",
-        "Justin",
-        "Joey",
-        "Joanna",
-        "Ivy",
-        "Raveena",
-        "Aditi",
-        "Emma",
-        "Brian",
-        "Amy",
-        "Russell",
-        "Nicole",
-        "Vicki",
-        "Marlene",
-        "Hans",
-        "Naja",
-        "Mads",
-        "Gwyneth",
-        "Zhiyu",
-        "es-ES-Standard-A",
-        "it-IT-Standard-A",
-        "it-IT-Wavenet-A",
-        "ja-JP-Standard-A",
-        "ja-JP-Wavenet-A",
-        "ko-KR-Standard-A",
-        "ko-KR-Wavenet-A",
-        "pt-BR-Standard-A",
-        "tr-TR-Standard-A",
-        "sv-SE-Standard-A",
-        "nl-NL-Standard-A",
-        "nl-NL-Wavenet-A",
-        "en-US-Wavenet-A",
-        "en-US-Wavenet-B",
-        "en-US-Wavenet-C",
-        "en-US-Wavenet-D",
-        "en-US-Wavenet-E",
-        "en-US-Wavenet-F",
-        "en-GB-Standard-A",
-        "en-GB-Standard-B",
-        "en-GB-Standard-C",
-        "en-GB-Standard-D",
-        "en-GB-Wavenet-A",
-        "en-GB-Wavenet-B",
-        "en-GB-Wavenet-C",
-        "en-GB-Wavenet-D",
-        "en-US-Standard-B",
-        "en-US-Standard-C",
-        "en-US-Standard-D",
-        "en-US-Standard-E",
-        "de-DE-Standard-A",
-        "de-DE-Standard-B",
-        "de-DE-Wavenet-A",
-        "de-DE-Wavenet-B",
-        "de-DE-Wavenet-C",
-        "de-DE-Wavenet-D",
-        "en-AU-Standard-A",
-        "en-AU-Standard-B",
-        "en-AU-Wavenet-A",
-        "en-AU-Wavenet-B",
-        "en-AU-Wavenet-C",
-        "en-AU-Wavenet-D",
-        "en-AU-Standard-C",
-        "en-AU-Standard-D",
-        "fr-CA-Standard-A",
-        "fr-CA-Standard-B",
-        "fr-CA-Standard-C",
-        "fr-CA-Standard-D",
-        "fr-FR-Standard-C",
-        "fr-FR-Standard-D",
-        "fr-FR-Wavenet-A",
-        "fr-FR-Wavenet-B",
-        "fr-FR-Wavenet-C",
-        "fr-FR-Wavenet-D",
-        "da-DK-Wavenet-A",
-        "pl-PL-Wavenet-A",
-        "pl-PL-Wavenet-B",
-        "pl-PL-Wavenet-C",
-        "pl-PL-Wavenet-D",
-        "pt-PT-Wavenet-A",
-        "pt-PT-Wavenet-B",
-        "pt-PT-Wavenet-C",
-        "pt-PT-Wavenet-D",
-        "ru-RU-Wavenet-A",
-        "ru-RU-Wavenet-B",
-        "ru-RU-Wavenet-C",
-        "ru-RU-Wavenet-D",
-        "sk-SK-Wavenet-A",
-        "tr-TR-Wavenet-A",
-        "tr-TR-Wavenet-B",
-        "tr-TR-Wavenet-C",
-        "tr-TR-Wavenet-D",
-        "tr-TR-Wavenet-E",
-        "uk-UA-Wavenet-A",
-        "ar-XA-Wavenet-A",
-        "ar-XA-Wavenet-B",
-        "ar-XA-Wavenet-C",
-        "cs-CZ-Wavenet-A",
-        "nl-NL-Wavenet-B",
-        "nl-NL-Wavenet-C",
-        "nl-NL-Wavenet-D",
-        "nl-NL-Wavenet-E",
-        "en-IN-Wavenet-A",
-        "en-IN-Wavenet-B",
-        "en-IN-Wavenet-C",
-        "fil-PH-Wavenet-A",
-        "fi-FI-Wavenet-A",
-        "el-GR-Wavenet-A",
-        "hi-IN-Wavenet-A",
-        "hi-IN-Wavenet-B",
-        "hi-IN-Wavenet-C",
-        "hu-HU-Wavenet-A",
-        "id-ID-Wavenet-A",
-        "id-ID-Wavenet-B",
-        "id-ID-Wavenet-C",
-        "it-IT-Wavenet-B",
-        "it-IT-Wavenet-C",
-        "it-IT-Wavenet-D",
-        "ja-JP-Wavenet-B",
-        "ja-JP-Wavenet-C",
-        "ja-JP-Wavenet-D",
-        "cmn-CN-Wavenet-A",
-        "cmn-CN-Wavenet-B",
-        "cmn-CN-Wavenet-C",
-        "cmn-CN-Wavenet-D",
-        "nb-no-Wavenet-E",
-        "nb-no-Wavenet-A",
-        "nb-no-Wavenet-B",
-        "nb-no-Wavenet-C",
-        "nb-no-Wavenet-D",
-        "vi-VN-Wavenet-A",
-        "vi-VN-Wavenet-B",
-        "vi-VN-Wavenet-C",
-        "vi-VN-Wavenet-D",
-        "sr-rs-Standard-A",
-        "lv-lv-Standard-A",
-        "is-is-Standard-A",
-        "bg-bg-Standard-A",
-        "af-ZA-Standard-A",
-        "Tracy",
-        "Danny",
-        "Huihui",
-        "Yaoyao",
-        "Kangkang",
-        "HanHan",
-        "Zhiwei",
-        "Asaf",
-        "An",
-        "Stefanos",
-        "Filip",
-        "Ivan",
-        "Heidi",
-        "Herena",
-        "Kalpana",
-        "Hemant",
-        "Matej",
-        "Andika",
-        "Rizwan",
-        "Lado",
-        "Valluvar",
-        "Linda",
-        "Heather",
-        "Sean",
-        "Michael",
-        "Karsten",
-        "Guillaume",
-        "Pattara",
-        "Jakub",
-        "Szabolcs",
-        "Hoda",
-        "Naayf",
-    ]
-
-    @classmethod
-    def text_to_audio(
-        cls,
-        message: str,
-        voice: str = "Brian",
-        save_to: Union[Path, str] = None,
-        auto: bool = True,
-    ) -> Union[str, bytes]:
-        """
-        Text to speech using StreamElements API
-
-        Parameters:
-            message (str): The text to convert to speech
-            voice (str, optional): The voice to use for speech synthesis. Defaults to "Brian".
-            save_to (bool, optional): Path to save the audio file. Defaults to None.
-            auto (bool, optional): Generate filename based on `message` and save to `cls.cache_dir`. Defaults to False.
-
-        Returns:
-            result (Union[str, bytes]): Path to saved contents or audio content.
-        """
-        assert (
-            voice in cls.all_voices
-        ), f"Voice '{voice}' not one of [{', '.join(cls.all_voices)}]"
-        # Base URL for provider API
-        url: str = (
-            f"https://api.streamelements.com/kappa/v2/speech?voice={voice}&text={{{urllib.parse.quote(message)}}}"
-        )
-        resp = requests.get(url=url, headers=cls.headers, stream=True)
-        if not resp.ok:
-            raise Exception(
-                f"Failed to perform the operation - ({resp.status_code}, {resp.reason}) - {resp.text}"
-            )
-
-        def sanitize_filename(path):
-            trash = [
-                "\\",
-                "/",
-                ":",
-                "*",
-                "?",
-                '"',
-                "<",
-                "|",
-                ">",
-            ]
-            for val in trash:
-                path = path.replace(val, "")
-            return path.strip()
-
-        if auto:
-            filename: str = message + "..." if len(message) <= 40 else message[:40]
-            save_to = cls.cache_dir / sanitize_filename(filename)
-            save_to = save_to.as_posix()
-
-        # Ensure cache_dir exists
-        cls.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        if save_to:
-            if not save_to.endswith("mp3"):
-                save_to += ".mp3"
+from .optimizers import Optimizers
 
-            with open(save_to, "wb") as fh:
-                for chunk in resp.iter_content(chunk_size=512):
-                    fh.write(chunk)
-        else:
-            return resp.content
-        return save_to
+from .Extra.autocoder import AutoCoder
 
-    @staticmethod
-    def play(path_to_audio_file: Union[Path, str]) -> NoReturn:
-        """Play audio (.mp3) using playsound.
-        """
-        if not Path(path_to_audio_file).is_file():
-            raise FileNotFoundError(f"File does not exist - '{path_to_audio_file}'")
-        playsound(path_to_audio_file)
-# 
+from .prompt_manager import AwesomePrompts