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

webscout/Provider/multichat.py

@@ -6,7 +6,6 @@ from datetime import datetime
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent 
 
 # Model configurations
@@ -21,14 +20,18 @@ MODEL_CONFIGS = {
     },
     "cohere": {
         "endpoint": "https://www.multichatai.com/api/chat/cohere",
-        "models": {"command-r": {"contextLength": 128000}},
+        "models": {
+            "command-r": {"contextLength": 128000},
+            "command": {"contextLength": 4096},
+        },
     },
     "google": {
         "endpoint": "https://www.multichatai.com/api/chat/google",
         "models": {
             "gemini-1.5-flash-002": {"contextLength": 1048576},
             "gemma2-9b-it": {"contextLength": 8192},
-        },
+            "gemini-2.0-flash": {"contextLength": 128000},
+                    },
         "message_format": "parts",
     },
     "deepinfra": {
@@ -38,6 +41,9 @@ MODEL_CONFIGS = {
             "Gryphe/MythoMax-L2-13b": {"contextLength": 8192},
             "nvidia/Llama-3.1-Nemotron-70B-Instruct": {"contextLength": 131072},
             "deepseek-ai/DeepSeek-V3": {"contextLength": 32000},
+            "meta-llama/Meta-Llama-3.1-405B-Instruct": {"contextLength": 131072},
+            "NousResearch/Hermes-3-Llama-3.1-405B": {"contextLength": 131072},
+            "gemma-2-27b-it": {"contextLength": 8192},
         },
     },
     "mistral": {
@@ -49,6 +55,14 @@ MODEL_CONFIGS = {
             "open-mixtral-8x7b": {"contextLength": 8000},
         },
     },
+    "alibaba": {
+        "endpoint": "https://www.multichatai.com/api/chat/alibaba",
+        "models": {
+            "Qwen/Qwen2.5-72B-Instruct": {"contextLength": 32768},
+            "Qwen/Qwen2.5-Coder-32B-Instruct": {"contextLength": 32768},
+            "Qwen/QwQ-32B-Preview": {"contextLength": 32768},
+        },
+    },
 }
 
 class MultiChatAI(Provider):
@@ -68,20 +82,9 @@ class MultiChatAI(Provider):
         temperature: float = 0.5,
         presence_penalty: int = 0,
         frequency_penalty: int = 0,
-        top_p: float = 1,
-        logging: bool = False,
+        top_p: float = 1
     ):
-        """Initializes the MultiChatAI API client with logging capabilities."""
-        # Initialize logger first
-        self.logger = Logger(
-            name="MultiChatAI",
-            format=LogFormat.MODERN_EMOJI,
-
-        ) if logging else None
-
-        if self.logger:
-            self.logger.debug("Initializing MultiChatAI")
-
+        """Initializes the MultiChatAI API client."""
         self.session = requests.Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -106,9 +109,6 @@ class MultiChatAI(Provider):
             "user-agent": self.agent.random(),
         }
         
-        if self.logger:
-            self.logger.debug(f"Setting up session with headers: {self.headers}")
-        
         self.session.headers.update(self.headers)
         self.session.proxies = proxies
         self.session.cookies.update({"session": uuid.uuid4().hex})
@@ -131,24 +131,17 @@ class MultiChatAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-        # Get provider after logger initialization
         self.provider = self._get_provider_from_model(self.model)
         self.model_name = self.model
 
-        if self.logger:
-            self.logger.info(f"MultiChatAI initialized with model: {self.model}")
-
     def _get_endpoint(self) -> str:
         """Get the API endpoint for the current provider."""
-        endpoint = MODEL_CONFIGS[self.provider]["endpoint"]
-        if self.logger:
-            self.logger.debug(f"Using endpoint: {endpoint}")
-        return endpoint
+        return MODEL_CONFIGS[self.provider]["endpoint"]
 
     def _get_chat_settings(self) -> Dict[str, Any]:
         """Get chat settings for the current model."""
         base_settings = MODEL_CONFIGS[self.provider]["models"][self.model_name]
-        settings = {
+        return {
             "model": self.model,
             "prompt": self.system_prompt,
             "temperature": self.temperature,
@@ -157,45 +150,30 @@ class MultiChatAI(Provider):
             "includeWorkspaceInstructions": True,
             "embeddingsProvider": "openai"
         }
-        if self.logger:
-            self.logger.debug(f"Chat settings: {settings}")
-        return settings
 
     def _get_system_message(self) -> str:
         """Generate system message with current date."""
         current_date = datetime.now().strftime("%d/%m/%Y")
-        message = f"Today is {current_date}.\n\nUser Instructions:\n{self.system_prompt}"
-        if self.logger:
-            self.logger.debug(f"System message: {message}")
-        return message
+        return f"Today is {current_date}.\n\nUser Instructions:\n{self.system_prompt}"
 
     def _build_messages(self, conversation_prompt: str) -> list:
         """Build messages array based on provider type."""
         if self.provider == "google":
-            messages = [
+            return [
                 {"role": "user", "parts": self._get_system_message()},
                 {"role": "model", "parts": "I will follow your instructions."},
                 {"role": "user", "parts": conversation_prompt}
             ]
         else:
-            messages = [
+            return [
                 {"role": "system", "content": self._get_system_message()},
                 {"role": "user", "content": conversation_prompt}
             ]
-        
-        if self.logger:
-            self.logger.debug(f"Built messages: {messages}")
-        return messages
 
     def _get_provider_from_model(self, model: str) -> str:
         """Determine the provider based on the model name."""
-        if self.logger:
-            self.logger.debug(f"Getting provider for model: {model}")
-            
         for provider, config in MODEL_CONFIGS.items():
             if model in config["models"]:
-                if self.logger:
-                    self.logger.info(f"Found provider: {provider} for model: {model}")
                 return provider
         
         available_models = []
@@ -204,16 +182,10 @@ class MultiChatAI(Provider):
                 available_models.append(f"{provider}/{model_name}")
         
         error_msg = f"Invalid model: {model}\nAvailable models: {', '.join(available_models)}"
-        if self.logger:
-            self.logger.error(error_msg)
         raise ValueError(error_msg)
 
     def _make_request(self, payload: Dict[str, Any]) -> requests.Response:
-        """Make the API request with proper error handling and logging."""
-        if self.logger:
-            self.logger.debug(f"Making request to endpoint: {self._get_endpoint()}")
-            self.logger.debug(f"Request payload: {json.dumps(payload, indent=2)}")
-
+        """Make the API request with proper error handling."""
         try:
             response = self.session.post(
                 self._get_endpoint(),
@@ -222,15 +194,8 @@ class MultiChatAI(Provider):
                 timeout=self.timeout,
             )
             response.raise_for_status()
-            
-            if self.logger:
-                self.logger.info(f"Request successful: {response.status_code}")
-                self.logger.debug(f"Response content: {response.text[:200]}...")
-                
             return response
         except requests.exceptions.RequestException as e:
-            if self.logger:
-                self.logger.error(f"Request failed: {str(e)}")
             raise exceptions.FailedToGenerateResponseError(f"API request failed: {e}") from e
 
     def ask(
@@ -241,21 +206,14 @@ class MultiChatAI(Provider):
         conversationally: bool = False,
     ) -> Dict[str, Any]:
         """Sends a prompt to the MultiChatAI API and returns the response."""
-        if self.logger:
-            self.logger.debug(f"ask() called with prompt: {prompt}")
-            
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
-                if self.logger:
-                    self.logger.info(f"Applying optimizer: {optimizer}")
                 conversation_prompt = getattr(Optimizers, optimizer)(
                     conversation_prompt if conversationally else prompt
                 )
             else:
                 error_msg = f"Optimizer is not one of {self.__available_optimizers}"
-                if self.logger:
-                    self.logger.error(error_msg)
                 raise exceptions.FailedToGenerateResponseError(error_msg)
 
         payload = {
@@ -269,15 +227,8 @@ class MultiChatAI(Provider):
             full_response = response.text.strip()
             self.last_response = {"text": full_response}
             self.conversation.update_chat_history(prompt, full_response)
-            
-            if self.logger:
-                self.logger.info("Successfully processed response")
-                self.logger.debug(f"Final response: {full_response[:200]}...")
-                
             return self.last_response
         except json.JSONDecodeError as e:
-            if self.logger:
-                self.logger.error(f"Failed to decode JSON response: {e}")
             raise exceptions.FailedToGenerateResponseError(f"Invalid JSON response: {e}") from e
 
     def chat(
@@ -286,17 +237,10 @@ class MultiChatAI(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> str:
-        """Generate response with logging."""
-        if self.logger:
-            self.logger.debug(f"chat() called with prompt: {prompt}")
-            
+        """Generate response."""
         response = self.ask(
             prompt, optimizer=optimizer, conversationally=conversationally
         )
-        
-        if self.logger:
-            self.logger.info("Chat response generated successfully")
-            
         return self.get_message(response)
 
     def get_message(self, response: Dict[str, Any] | str) -> str:
@@ -309,21 +253,15 @@ class MultiChatAI(Provider):
         Returns:
             str: The extracted message text
         """
-        if self.logger:
-            self.logger.debug(f"Extracting message from response type: {type(response)}")
-            
         if isinstance(response, dict):
-            message = response.get("text", "")
-            if self.logger:
-                self.logger.debug(f"Extracted message from dict: {message[:200]}...")
-            return message
+            return response.get("text", "")
         return str(response)
 
 if __name__ == "__main__":
     from rich import print
 
-    # Example usage with logging enabled
-    ai = MultiChatAI(model="deepseek-r1-distill-llama-70b", logging=False)
+    # Example usage
+    ai = MultiChatAI(model="Qwen/QwQ-32B-Preview")
     try:
         response = ai.chat("What is quantum computing?")
         print(response)

webscout/exceptions.py

@@ -11,7 +11,7 @@ class WebscoutE(Exception):
     pass
 
 
-class APIConnectionError(Exception):
+class APIConnectionError(WebscoutE):
     """
     Exception raised when there are issues connecting to an API.
 
@@ -21,7 +21,17 @@ class APIConnectionError(Exception):
     pass
 
 
-class RatelimitE(Exception):
+class AuthenticationError(WebscoutE):
+    """
+    Exception raised when authentication to a service fails.
+
+    This exception is raised when the provided credentials are invalid or expired.
+    It indicates that the application cannot authenticate with the service.
+    """
+    pass
+
+
+class RatelimitE(WebscoutE):
     """
     Exception raised when an API rate limit is exceeded.
 
@@ -31,7 +41,7 @@ class RatelimitE(Exception):
     pass
 
 
-class ConversationLimitException(Exception):
+class ConversationLimitException(WebscoutE):
     """
     Exception raised when a conversation limit is exceeded.
 
@@ -41,7 +51,7 @@ class ConversationLimitException(Exception):
     pass
 
 
-class TimeoutE(Exception):
+class TimeoutE(WebscoutE):
     """
     Exception raised when a request to an API times out.
 
@@ -51,7 +61,7 @@ class TimeoutE(Exception):
     pass
 
 
-class FailedToGenerateResponseError(Exception):
+class FailedToGenerateResponseError(WebscoutE):
     """
     Exception raised when a provider fails to generate a response.
 
@@ -61,7 +71,7 @@ class FailedToGenerateResponseError(Exception):
     pass
 
 
-class AllProvidersFailure(Exception):
+class AllProvidersFailure(WebscoutE):
     """
     Exception raised when all providers fail to generate a response.
 
@@ -71,7 +81,7 @@ class AllProvidersFailure(Exception):
     pass
 
 
-class FacebookInvalidCredentialsException(Exception):
+class FacebookInvalidCredentialsException(WebscoutE):
     """
     Exception raised when Facebook credentials are invalid.
 
@@ -81,7 +91,7 @@ class FacebookInvalidCredentialsException(Exception):
     pass
 
 
-class FacebookRegionBlocked(Exception):
+class FacebookRegionBlocked(WebscoutE):
     """
     Exception raised when Facebook access is blocked due to region restrictions.
 
@@ -91,7 +101,7 @@ class FacebookRegionBlocked(Exception):
     pass
 
 
-class ModelUnloadedException(Exception):
+class ModelUnloadedException(WebscoutE):
     """
     Exception raised when a model is unloaded.
 

webscout/update_checker.py

@@ -1,43 +1,28 @@
 """
-Ayy, check it out! 👀
+Webscout Update Checker
 >>> from webscout import check_for_updates
->>> check_for_updates()
-'Yo, new Webscout version just dropped: 2.0.0! 🔥
-Level up with: `pip install --upgrade webscout`'
+>>> result = check_for_updates()
+>>> print(result)
+'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
 """
 
-import subprocess
 import sys
 import os
-from typing import Optional
+from typing import Optional, Tuple, Dict, Any, Literal, Union
 
 import requests
 from packaging import version
-import re
-
-from webscout.Litlogger import Logger
 from importlib.metadata import version as get_package_version
 from importlib.metadata import PackageNotFoundError
-from importlib.metadata import metadata as get_package_metadata
-
-# Setting up that clean logger format, no cap! 💯
-CUSTOM_FORMAT = """{message}"""
 
-logger = Logger(
-    name="WebscoutUpdate",
-    format=CUSTOM_FORMAT,
-)
+# Version comparison result type
+VersionCompareResult = Literal[-1, 0, 1]
 
 def get_installed_version() -> Optional[str]:
-    """Yo, let's check what version you're running! 🔍
-
-    What this function's all about:
-    - Checking your setup real quick 💨
-    - Getting them version deets 📱
-    - Handling any problems like a boss 💪
+    """Get the currently installed version of webscout.
 
     Returns:
-        Optional[str]: Your version number or None if we can't find it
+        Optional[str]: The installed version string or None if not found
 
     Examples:
         >>> version = get_installed_version()
@@ -48,19 +33,14 @@ def get_installed_version() -> Optional[str]:
         return get_package_version('webscout')
     except PackageNotFoundError:
         return None
-    except Exception as e:
+    except Exception:
         return None
 
 def get_pypi_version() -> Optional[str]:
-    """Let's see what's fresh on PyPI! 🚀
-
-    This function's vibe:
-    - Hitting up PyPI for the latest drop 🌐
-    - Keeping it smooth with timeout handling ⚡
-    - Making sure we get good data fr fr 💯
+    """Get the latest version available on PyPI.
 
     Returns:
-        Optional[str]: Latest version or None if something's not right
+        Optional[str]: The latest version string or None if retrieval failed
 
     Examples:
         >>> latest = get_pypi_version()
@@ -73,24 +53,20 @@ def get_pypi_version() -> Optional[str]:
             timeout=10
         )
         response.raise_for_status()
-        return response.json()['info']['version']
-    except requests.RequestException as e:
-        pass
-    except (KeyError, ValueError) as e:
-        pass
-    except Exception as e:
-        pass
-    return None
+        data: Dict[str, Any] = response.json()
+        return data['info']['version']
+    except (requests.RequestException, KeyError, ValueError, Exception):
+        return None
 
-def version_compare(v1: str, v2: str) -> int:
-    """Time to compare these versions! 💪
+def version_compare(v1: str, v2: str) -> VersionCompareResult:
+    """Compare two version strings.
 
     Args:
-        v1: First version we checking
-        v2: Second version to compare with
+        v1: First version string
+        v2: Second version string to compare with
 
     Returns:
-        int: -1 if v1's older, 1 if v1's newer, 0 if they twins
+        VersionCompareResult: -1 if v1 < v2, 1 if v1 > v2, 0 if equal
 
     Examples:
         >>> version_compare('1.0.0', '2.0.0')
@@ -104,71 +80,57 @@ def version_compare(v1: str, v2: str) -> int:
         if version1 > version2:
             return 1
         return 0
-    except version.InvalidVersion as e:
-        pass
-        return 0
-    except Exception as e:
-        pass
+    except (version.InvalidVersion, Exception):
         return 0
 
-def display_version_info(installed: Optional[str], latest: Optional[str]) -> None:
-    """Let's break down your version status! 📱
-
-    What we doing here:
-    - Comparing your version with the latest drop 🔄
-    - Letting you know if you need to level up ⬆️
-    - Keeping you in the loop with style 💯
+def get_update_message(installed: str, latest: str) -> Optional[str]:
+    """Generate appropriate update message based on version comparison.
 
     Args:
-        installed: What you running rn
-        latest: What's fresh out there
+        installed: Currently installed version
+        latest: Latest available version
+
+    Returns:
+        Optional[str]: Update message if needed, None if already on latest version
 
     Examples:
-        >>> display_version_info('1.0.0', '2.0.0')
-        'Yo, new Webscout version just dropped: 2.0.0! 🔥'
+        >>> get_update_message('1.0.0', '2.0.0')
+        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
     """
-    if installed:
-        pass
-    
-    if latest and installed:
-        comparison_result = version_compare(installed, latest)
-        if comparison_result < 0:
-            logger.warning(
-                f"Yo, new Webscout version just dropped: {latest}! 🔥\n"
-                f"Level up with: `pip install --upgrade webscout`"
-            )
-        elif comparison_result > 0:
-            logger.success("You already got the latest version, no cap! 💯")
-
-def check_for_updates() -> None:
-    """Time to check if you're running the latest! 🚀
-
-    What we doing:
-    - Peeking at your current setup 📱
-    - Checking what's new out there 🌐
-    - Keeping you updated fr fr ⚡
+    comparison_result = version_compare(installed, latest)
+    if comparison_result < 0:
+        return f"New Webscout version available: {latest} - Update with: pip install --upgrade webscout"
+    elif comparison_result > 0:
+        return f"You're running a development version ({installed}) ahead of latest release ({latest})"
+    return None  # Already on the latest version
+
+def check_for_updates() -> Optional[str]:
+    """Check if a newer version of Webscout is available.
+
+    Returns:
+        Optional[str]: Update message if newer version exists, None otherwise
 
     Examples:
-        >>> check_for_updates()
-        # We got you with them version checks fam!
+        >>> result = check_for_updates()
+        >>> print(result)
+        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
     """
     installed_version = get_installed_version()
-    latest_version = get_pypi_version()
-    
     if not installed_version:
-        pass
-        return
+        return None
         
+    latest_version = get_pypi_version()
     if not latest_version:
-        pass
-        return
+        return None
     
-    display_version_info(installed_version, latest_version)
+    return get_update_message(installed_version, latest_version)
 
 if __name__ == "__main__":
     try:
-        check_for_updates()
+        update_message = check_for_updates()
+        if update_message:
+            print(update_message)
     except KeyboardInterrupt:
-        logger.warning("Update check got cancelled, no worries fam! 🤚")
+        print("Update check canceled")
     except Exception as e:
-        logger.error(f"Uh oh, something went wrong: {str(e)} 😔")
+        print(f"Update check failed: {str(e)}")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "7.4"
+__version__ = "7.5"
 __prog__ = "webscout"