webscout 6.3__py3-none-any.whl → 6.5__py3-none-any.whl

webscout/AIauto.py

@@ -1,176 +1,191 @@
-from webscout.AIbase import Provider
-from webscout.g4f import GPT4FREE, TestProviders
-from webscout.exceptions import AllProvidersFailure
-from typing import Union, Any, Dict, Generator
-import importlib
-import pkgutil
-import logging
-import random
-import inspect
-
-def load_providers():
-    provider_map = {}
-    api_key_providers = set()
-    provider_package = importlib.import_module("webscout.Provider")
-    
-    for _, module_name, _ in pkgutil.iter_modules(provider_package.__path__):
-        try:
-            module = importlib.import_module(f"webscout.Provider.{module_name}")
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if isinstance(attr, type) and issubclass(attr, Provider) and attr != Provider:
-                    provider_map[attr_name.upper()] = attr
-                    # Check if the provider needs an API key
-                    if 'api_key' in inspect.signature(attr.__init__).parameters:
-                        api_key_providers.add(attr_name.upper())
-        except Exception as e:
-            logging.warning(f"Failed to load provider {module_name}: {e}")
-    
-    return provider_map, api_key_providers
-
-provider_map, api_key_providers = load_providers()
-
-class AUTO(Provider):
-    def __init__(
-        self,
-        is_conversation: bool = True,
-        max_tokens: int = 600,
-        timeout: int = 30,
-        intro: str = None,
-        filepath: str = None,
-        update_file: bool = True,
-        proxies: dict = {},
-        history_offset: int = 10250,
-        act: str = None,
-        exclude: list[str] = [],
-    ):
-        self.provider = None
-        self.provider_name = None
-        self.is_conversation = is_conversation
-        self.max_tokens = max_tokens
-        self.timeout = timeout
-        self.intro = intro
-        self.filepath = filepath
-        self.update_file = update_file
-        self.proxies = proxies
-        self.history_offset = history_offset
-        self.act = act
-        self.exclude = [e.upper() for e in exclude]
-
-    @property
-    def last_response(self) -> dict[str, Any]:
-        return self.provider.last_response if self.provider else {}
-
-    @property
-    def conversation(self) -> object:
-        return self.provider.conversation if self.provider else None
-
-    def ask(
-        self,
-        prompt: str,
-        stream: bool = False,
-        raw: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-        run_new_test: bool = False,
-    ) -> Union[Dict, Generator]:
-        ask_kwargs = {
-            "prompt": prompt,
-            "stream": stream,
-            "raw": raw,
-            "optimizer": optimizer,
-            "conversationally": conversationally,
-        }
-
-        # Filter out API key required providers and excluded providers
-        available_providers = [
-            (name, cls) for name, cls in provider_map.items()
-            if name not in api_key_providers and name not in self.exclude
-        ]
-
-        # Shuffle the list of available providers
-        random.shuffle(available_providers)
-
-        # Try webscout-based providers
-        for provider_name, provider_class in available_providers:
-            try:
-                self.provider_name = f"webscout-{provider_name}"
-                self.provider = provider_class(
-                    is_conversation=self.is_conversation,
-                    max_tokens=self.max_tokens,
-                    timeout=self.timeout,
-                    intro=self.intro,
-                    filepath=self.filepath,
-                    update_file=self.update_file,
-                    proxies=self.proxies,
-                    history_offset=self.history_offset,
-                    act=self.act,
-                )
-
-                return self.provider.ask(**ask_kwargs)
-
-            except Exception as e:
-                logging.debug(
-                    f"Failed to generate response using provider {provider_name} - {e}"
-                )
-
-        # 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']}"
-                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,
-                )
-
-                print(f"Using provider: {self.provider_name}")
-                return self.provider.ask(**ask_kwargs)
-
-            except Exception as e:
-                logging.debug(
-                    f"Failed to generate response using GPT4FREE-based provider {provider_info['name']} - {e}"
-                )
-
-        raise AllProvidersFailure("None of the providers generated response successfully.")
-
-    def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-        run_new_test: bool = False,
-    ) -> Union[str, Generator[str, None, None]]:
-        response = self.ask(
-            prompt,
-            stream,
-            optimizer=optimizer,
-            conversationally=conversationally,
-            run_new_test=run_new_test,
-        )
-        
-        if stream:
-            return (self.get_message(chunk) for chunk in response)
-        else:
-            return self.get_message(response)
-
-    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)
+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()
+    provider_package = importlib.import_module("webscout.Provider")
+    
+    for _, module_name, _ in pkgutil.iter_modules(provider_package.__path__):
+        try:
+            module = importlib.import_module(f"webscout.Provider.{module_name}")
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if isinstance(attr, type) and issubclass(attr, Provider) and attr != Provider:
+                    provider_map[attr_name.upper()] = attr
+                    # 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)}")
+    return provider_map, api_key_providers
+
+provider_map, api_key_providers = load_providers()
+
+class AUTO(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        exclude: list[str] = [],
+    ):
+        self.provider = None
+        self.provider_name = None
+        self.is_conversation = is_conversation
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.intro = intro
+        self.filepath = filepath
+        self.update_file = update_file
+        self.proxies = proxies
+        self.history_offset = history_offset
+        self.act = act
+        self.exclude = [e.upper() for e in exclude]
+
+    @property
+    def last_response(self) -> dict[str, Any]:
+        return self.provider.last_response if self.provider else {}
+
+    @property
+    def conversation(self) -> object:
+        return self.provider.conversation if self.provider else None
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> Union[Dict, Generator]:
+        ask_kwargs = {
+            "prompt": prompt,
+            "stream": stream,
+            "raw": raw,
+            "optimizer": optimizer,
+            "conversationally": conversationally,
+        }
+
+        # Filter out API key required providers and excluded providers
+        available_providers = [
+            (name, cls) for name, cls in provider_map.items()
+            if name not in api_key_providers and name not in self.exclude
+        ]
+
+        # Shuffle the list of available providers
+        random.shuffle(available_providers)
+
+        # Try webscout-based providers
+        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,
+                    max_tokens=self.max_tokens,
+                    timeout=self.timeout,
+                    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)}")
+                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)}")
+                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(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        response = self.ask(
+            prompt,
+            stream,
+            optimizer=optimizer,
+            conversationally=conversationally,
+            run_new_test=run_new_test,
+        )
+        
+        if stream:
+            return (self.get_message(chunk) for chunk in response)
+        else:
+            return self.get_message(response)
+
+    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/AIbase.py

@@ -10,16 +10,9 @@ ImageData: TypeAlias = Union[bytes, str, Generator[bytes, None, None]]
 AsyncImageData: TypeAlias = Union[bytes, str, AsyncGenerator[bytes, None]]
 
 class AIProviderError(Exception):
-    """Base exception for AI provider errors"""
     pass
 
 class Provider(ABC):
-    """Base class for text-based AI providers.
-    
-    This class defines the interface for synchronous AI text generation providers.
-    All text-based AI providers should inherit from this class and implement
-    its abstract methods.
-    """
 
     @abstractmethod
     def ask(
@@ -30,30 +23,6 @@ class Provider(ABC):
         optimizer: Optional[str] = None,
         conversationally: bool = False,
     ) -> Response:
-        """Chat with AI and get detailed response.
-
-        Args:
-            prompt: The input text to send to the AI
-            stream: Whether to stream the response. Defaults to False
-            raw: Whether to return raw response as received. Defaults to False
-            optimizer: Optional prompt optimizer - choices: ['code', 'shell_command']
-            conversationally: Whether to maintain conversation context. Defaults to False
-
-        Returns:
-            A dictionary containing response details:
-            {
-                "completion": str,        # The AI's response
-                "stop_reason": str|None,  # Reason for response termination
-                "truncated": bool,        # Whether response was truncated
-                "stop": str|None,        # Stop token if any
-                "model": str,            # Model used for generation
-                "log_id": str,           # Unique log identifier
-                "exception": str|None    # Error message if any
-            }
-
-        Raises:
-            AIProviderError: If there's an error communicating with the AI provider
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
@@ -64,39 +33,13 @@ class Provider(ABC):
         optimizer: Optional[str] = None,
         conversationally: bool = False,
     ) -> str:
-        """Generate a simple text response from the AI.
-
-        Args:
-            prompt: The input text to send to the AI
-            stream: Whether to stream the response. Defaults to False
-            optimizer: Optional prompt optimizer - choices: ['code', 'shell_command']
-            conversationally: Whether to maintain conversation context. Defaults to False
-
-        Returns:
-            The AI's text response
-
-        Raises:
-            AIProviderError: If there's an error communicating with the AI provider
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
     def get_message(self, response: Response) -> str:
-        """Extract the message content from a response dictionary.
-
-        Args:
-            response: Response dictionary from ask() method
-
-        Returns:
-            The extracted message text
-
-        Raises:
-            AIProviderError: If message cannot be extracted from response
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
 class AsyncProvider(ABC):
-    """Asynchronous base class for text-based AI providers"""
 
     @abstractmethod
     async def ask(
@@ -107,30 +50,6 @@ class AsyncProvider(ABC):
         optimizer: Optional[str] = None,
         conversationally: bool = False,
     ) -> Response:
-        """Asynchronously chat with AI and get detailed response.
-
-        Args:
-            prompt: The input text to send to the AI
-            stream: Whether to stream the response. Defaults to False
-            raw: Whether to return raw response as received. Defaults to False
-            optimizer: Optional prompt optimizer - choices: ['code', 'shell_command']
-            conversationally: Whether to maintain conversation context. Defaults to False
-
-        Returns:
-            A dictionary containing response details:
-            {
-                "completion": str,        # The AI's response
-                "stop_reason": str|None,  # Reason for response termination
-                "truncated": bool,        # Whether response was truncated
-                "stop": str|None,        # Stop token if any
-                "model": str,            # Model used for generation
-                "log_id": str,           # Unique log identifier
-                "exception": str|None    # Error message if any
-            }
-
-        Raises:
-            AIProviderError: If there's an error communicating with the AI provider
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
@@ -141,100 +60,28 @@ class AsyncProvider(ABC):
         optimizer: Optional[str] = None,
         conversationally: bool = False,
     ) -> str:
-        """Asynchronously generate a simple text response from the AI.
-
-        Args:
-            prompt: The input text to send to the AI
-            stream: Whether to stream the response. Defaults to False
-            optimizer: Optional prompt optimizer - choices: ['code', 'shell_command']
-            conversationally: Whether to maintain conversation context. Defaults to False
-
-        Returns:
-            The AI's text response
-
-        Raises:
-            AIProviderError: If there's an error communicating with the AI provider
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
     async def get_message(self, response: Response) -> str:
-        """Asynchronously extract the message content from a response dictionary.
-
-        Args:
-            response: Response dictionary from ask() method
-
-        Returns:
-            The extracted message text
-
-        Raises:
-            AIProviderError: If message cannot be extracted from response
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
 class TTSProvider(ABC):
-    """Base class for text-to-speech providers.
-    
-    This class defines the interface for synchronous text-to-speech providers.
-    """
 
     @abstractmethod
     def tts(self, text: str) -> ImageData:
-        """Convert text to speech.
-
-        Args:
-            text: The text to convert to speech
-
-        Returns:
-            One of:
-            - Raw audio bytes
-            - Path to saved audio file
-            - Generator yielding audio chunks
-
-        Raises:
-            AIProviderError: If text-to-speech conversion fails
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
 class AsyncTTSProvider(ABC):
-    """Base class for asynchronous text-to-speech providers."""
 
     @abstractmethod
     async def tts(self, text: str) -> AsyncImageData:
-        """Asynchronously convert text to speech.
-
-        Args:
-            text: The text to convert to speech
-
-        Returns:
-            One of:
-            - Raw audio bytes
-            - Path to saved audio file
-            - AsyncGenerator yielding audio chunks
-
-        Raises:
-            AIProviderError: If text-to-speech conversion fails
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
 class ImageProvider(ABC):
-    """Base class for text-to-image generation providers."""
 
     @abstractmethod
     def generate(self, prompt: str, amount: int = 1) -> List[bytes]:
-        """Generate images from a text description.
-
-        Args:
-            prompt: Text description of desired image
-            amount: Number of images to generate (default: 1)
-
-        Returns:
-            List of generated images as bytes
-
-        Raises:
-            AIProviderError: If image generation fails
-            ValueError: If amount is less than 1
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
@@ -244,24 +91,9 @@ class ImageProvider(ABC):
         name: Optional[str] = None, 
         dir: Optional[Union[str, Path]] = None
     ) -> List[str]:
-        """Save generated images to disk.
-
-        Args:
-            response: List of image data in bytes
-            name: Base filename for saved images (default: auto-generated)
-            dir: Directory to save images (default: current directory)
-
-        Returns:
-            List of paths to saved image files
-
-        Raises:
-            AIProviderError: If saving images fails
-            ValueError: If response is empty
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
 class AsyncImageProvider(ABC):
-    """Base class for asynchronous text-to-image generation providers."""
 
     @abstractmethod
     async def generate(
@@ -269,21 +101,6 @@ class AsyncImageProvider(ABC):
         prompt: str, 
         amount: int = 1
     ) -> Union[AsyncGenerator[bytes, None], List[bytes]]:
-        """Asynchronously generate images from text.
-
-        Args:
-            prompt: Text description of desired image
-            amount: Number of images to generate (default: 1)
-
-        Returns:
-            Either:
-            - AsyncGenerator yielding image bytes for streaming
-            - List of image bytes if not streaming
-
-        Raises:
-            AIProviderError: If image generation fails
-            ValueError: If amount is less than 1
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
     @abstractmethod
@@ -293,18 +110,4 @@ class AsyncImageProvider(ABC):
         name: Optional[str] = None,
         dir: Optional[Union[str, Path]] = None
     ) -> List[str]:
-        """Asynchronously save generated images.
-
-        Args:
-            response: Either AsyncGenerator yielding images or List of image bytes
-            name: Base filename for saved images (default: auto-generated)
-            dir: Directory to save images (default: current directory)
-
-        Returns:
-            List of paths to saved image files
-
-        Raises:
-            AIProviderError: If saving images fails
-            ValueError: If response is empty
-        """
         raise NotImplementedError("Method needs to be implemented in subclass")