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

webscout/LLM.py

@@ -1,100 +1,279 @@
-import requests
-import base64
-from typing import List, Dict, Union
-import json
-import requests
-import base64
-from typing import List, Dict, Union
-
-class LLM:
-    def __init__(self, model: str, system_message: str = "You are a Helpful AI."):
-        self.model = model
-        self.conversation_history = [{"role": "system", "content": system_message}]
-
-    def chat(self, messages: List[Dict[str, str]]) -> Union[str, None]:
-        url = "https://api.deepinfra.com/v1/openai/chat/completions"
-        headers = {
-            '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',
-            'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Content-Type': 'application/json',
-            'Origin': 'https://deepinfra.com',
-            'Pragma': 'no-cache',
-            'Referer': 'https://deepinfra.com/',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-site',
-            'X-Deepinfra-Source': 'web-embed',
-            'accept': 'text/event-stream',
-            'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"macOS"'
-        }
-        data = json.dumps(
-            {
-                'model': self.model,
-                'messages': messages,
-                'temperature': 0.7,
-                'max_tokens': 8028,
-                'stop': [],
-                'stream': False #dont change it
-            }, separators=(',', ':')
-        )
-        try:
-            result = requests.post(url=url, data=data, headers=headers)
-            return result.json()['choices'][0]['message']['content']
-        except:
-            return None
-# def main():
-#     llm = LLM(model="meta-llama/Meta-Llama-3-70B-Instruct")
-#     messages = [
-#         {"role": "user", "content": "Hello, how are you?"}
-#     ]
-#     response = llm.chat(messages)
-#     print(response)
-
-# if __name__ == "__main__":
-#     main()
-
-
-class VLM:
-    def __init__(self, model: str, system_message: str = "You are a Helpful AI."):
-        self.model = model
-        self.conversation_history = [{"role": "system", "content": system_message}]
-
-    def chat(self, messages: List[Dict[str, Union[str, List[Dict[str, Union[str, Dict[str, str]]]]]]]) -> Union[str, None]:
-        api_url = "https://api.deepinfra.com/v1/openai/chat/completions"
-        headers = {
-            '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',
-            'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Content-Type': 'application/json',
-            'Origin': 'https://deepinfra.com',
-            'Pragma': 'no-cache',
-            'Referer': 'https://deepinfra.com/',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-site',
-            'X-Deepinfra-Source': 'web-embed',
-            'accept': 'text/event-stream',
-            'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"macOS"'
-        }
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "stream": False
-        }
-        try:
-            response = requests.post(api_url, headers=headers, json=payload)
-            return response.json()['choices'][0]['message']['content']
-        except Exception as e:
-            print(f"An error occurred: {e}")
-            return None
-
-def encode_image_to_base64(image_path: str) -> str:
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode("utf-8")
+import requests
+import base64
+import json
+from typing import List, Dict, Union, Generator, Optional, Any
+
+class LLMError(Exception):
+    """Custom exception for LLM API errors"""
+    pass
+
+class LLM:
+    """A class for interacting with the DeepInfra LLM API."""
+    
+    def __init__(self, model: str, system_message: str = "You are a Helpful AI."):
+        """
+        Initialize the LLM client.
+        
+        Args:
+            model: The model identifier (e.g., "meta-llama/Meta-Llama-3-70B-Instruct")
+            system_message: The system message to use for the conversation
+        """
+        self.model = model
+        self.api_url = "https://api.deepinfra.com/v1/openai/chat/completions"
+        self.conversation_history = [{"role": "system", "content": system_message}]
+        self.headers = {
+            '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',
+            'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Content-Type': 'application/json',
+            'Origin': 'https://deepinfra.com',
+            'Pragma': 'no-cache',
+            'Referer': 'https://deepinfra.com/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-site',
+            'X-Deepinfra-Source': 'web-embed',
+            'accept': 'text/event-stream',
+            'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"macOS"'
+        }
+
+    def _prepare_payload(
+        self, 
+        messages: List[Dict[str, str]], 
+        stream: bool = False,
+        temperature: float = 0.7,
+        max_tokens: int = 8028,
+        stop: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Prepare the API request payload."""
+        return {
+            'model': self.model,
+            'messages': messages,
+            'temperature': temperature,
+            'max_tokens': max_tokens,
+            'stop': stop or [],
+            'stream': stream
+        }
+
+    def chat(
+        self, 
+        messages: List[Dict[str, str]], 
+        stream: bool = False,
+        temperature: float = 0.7,
+        max_tokens: int = 8028,
+        stop: Optional[List[str]] = None,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Send a chat request to the DeepInfra API.
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            stream: Whether to stream the response
+            temperature: Sampling temperature (0-1)
+            max_tokens: Maximum tokens to generate
+            stop: Optional list of stop sequences
+            
+        Returns:
+            Either a string response or a generator for streaming
+            
+        Raises:
+            LLMError: If the API request fails
+        """
+        payload = self._prepare_payload(messages, stream, temperature, max_tokens, stop)
+        
+        try:
+            if stream:
+                return self._stream_response(payload)
+            else:
+                return self._send_request(payload)
+        except Exception as e:
+            raise LLMError(f"API request failed: {str(e)}")
+
+    def _stream_response(self, payload: Dict[str, Any]) -> Generator[str, None, None]:
+        """Stream the chat response."""
+        try:
+            with requests.post(self.api_url, json=payload, headers=self.headers, stream=True) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line:
+                        if line.strip() == b'data: [DONE]':
+                            break
+                        if line.startswith(b'data: '):
+                            try:
+                                chunk = json.loads(line.decode('utf-8').removeprefix('data: '))
+                                if content := chunk.get('choices', [{}])[0].get('delta', {}).get('content'):
+                                    yield content
+                            except json.JSONDecodeError:
+                                continue
+        except requests.RequestException as e:
+            raise LLMError(f"Stream request failed: {str(e)}")
+
+    def _send_request(self, payload: Dict[str, Any]) -> str:
+        """Send a non-streaming chat request."""
+        try:
+            response = requests.post(self.api_url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        except requests.RequestException as e:
+            raise LLMError(f"Request failed: {str(e)}")
+        except (KeyError, IndexError) as e:
+            raise LLMError(f"Invalid response format: {str(e)}")
+        except json.JSONDecodeError as e:
+            raise LLMError(f"Invalid JSON response: {str(e)}")
+
+
+class VLM:
+    """A class for interacting with the DeepInfra VLM (Vision Language Model) API."""
+    
+    def __init__(self, model: str, system_message: str = "You are a Helpful AI."):
+        """
+        Initialize the VLM client.
+        
+        Args:
+            model: The model identifier
+            system_message: The system message to use for the conversation
+        """
+        self.model = model
+        self.api_url = "https://api.deepinfra.com/v1/openai/chat/completions"
+        self.conversation_history = [{"role": "system", "content": system_message}]
+        self.headers = {
+            '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',
+            'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Content-Type': 'application/json',
+            'Origin': 'https://deepinfra.com',
+            'Pragma': 'no-cache',
+            'Referer': 'https://deepinfra.com/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-site',
+            'X-Deepinfra-Source': 'web-embed',
+            'accept': 'text/event-stream',
+            'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"macOS"'
+        }
+
+    def chat(
+        self, 
+        messages: List[Dict[str, Union[str, List[Dict[str, Union[str, Dict[str, str]]]]]]], 
+        stream: bool = False,
+        temperature: float = 0.7,
+        max_tokens: int = 8028,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Send a chat request with image support to the DeepInfra API.
+        
+        Args:
+            messages: List of message dictionaries that may include image data
+            stream: Whether to stream the response
+            temperature: Sampling temperature (0-1)
+            max_tokens: Maximum tokens to generate
+            
+        Returns:
+            Either a string response or a generator for streaming
+            
+        Raises:
+            LLMError: If the API request fails
+        """
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": stream,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+
+        try:
+            if stream:
+                return self._stream_response(payload)
+            else:
+                return self._send_request(payload)
+        except Exception as e:
+            raise LLMError(f"VLM API request failed: {str(e)}")
+
+    def _stream_response(self, payload: Dict[str, Any]) -> Generator[str, None, None]:
+        """Stream the VLM chat response."""
+        try:
+            with requests.post(self.api_url, json=payload, headers=self.headers, stream=True) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line:
+                        if line.strip() == b'data: [DONE]':
+                            break
+                        if line.startswith(b'data: '):
+                            try:
+                                chunk = json.loads(line.decode('utf-8').removeprefix('data: '))
+                                if content := chunk.get('choices', [{}])[0].get('delta', {}).get('content'):
+                                    yield content
+                            except json.JSONDecodeError:
+                                continue
+        except requests.RequestException as e:
+            raise LLMError(f"VLM stream request failed: {str(e)}")
+
+    def _send_request(self, payload: Dict[str, Any]) -> str:
+        """Send a non-streaming VLM chat request."""
+        try:
+            response = requests.post(self.api_url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        except requests.RequestException as e:
+            raise LLMError(f"VLM request failed: {str(e)}")
+        except (KeyError, IndexError) as e:
+            raise LLMError(f"Invalid VLM response format: {str(e)}")
+        except json.JSONDecodeError as e:
+            raise LLMError(f"Invalid VLM JSON response: {str(e)}")
+
+
+def encode_image_to_base64(image_path: str) -> str:
+    """
+    Encode an image file to base64 string.
+    
+    Args:
+        image_path: Path to the image file
+        
+    Returns:
+        Base64 encoded string of the image
+        
+    Raises:
+        IOError: If the image file cannot be read
+    """
+    try:
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+    except IOError as e:
+        raise LLMError(f"Failed to read image file: {str(e)}")
+
+
+if __name__ == "__main__":
+    # Example usage
+    try:
+        # Initialize LLM with Llama 3 model
+        llm = LLM(model="Qwen/Qwen2.5-Coder-32B-Instruct")
+        
+        # Example messages
+        messages = [
+            {"role": "user", "content": "Write a short poem about AI."}
+        ]
+        
+        # Example 1: Non-streaming response
+        print("\nNon-streaming response:")
+        response = llm.chat(messages, stream=False)
+        print(response)
+        
+        # Example 2: Streaming response
+        print("\nStreaming response:")
+        for chunk in llm.chat(messages, stream=True):
+            print(chunk, end='', flush=True)
+        print("\n")
+        
+    except LLMError as e:
+        print(f"Error: {str(e)}")
+    except KeyboardInterrupt:
+        print("\nOperation cancelled by user")

webscout/Provider/Amigo.py

@@ -16,12 +16,17 @@ class AmigoChat(Provider):
     """
 
     AVAILABLE_MODELS = [
-        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",  # Llama 3
-        "o1-mini",                                   # OpenAI O1 Mini
-        "claude-3-sonnet-20240229",                  # Claude Sonnet
-        "gemini-1.5-pro",                             # Gemini Pro
-        "gemini-1-5-flash",                            # Gemini Flash
-        "o1-preview",                                 # OpenAI O1 Preview
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",    # Llama 3
+        "o1-mini",                                          # OpenAI O1 Mini
+        "claude-3-sonnet-20240229",                         # Claude Sonnet
+        "gemini-1.5-pro",                                   # Gemini Pro
+        "gemini-1-5-flash",                                 # Gemini Flash
+        "o1-preview",                                       # OpenAI O1 Preview
+        "claude-3-5-sonnet-20241022",                       # Claude 3.5 Sonnet
+        "Qwen/Qwen2.5-72B-Instruct-Turbo",                  # Qwen 2.5
+        "gpt-4o"                                            # OpenAI GPT-4o
+        "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo"    # Llama 3.2
+
     ]
 
     def __init__(
@@ -29,13 +34,15 @@ class AmigoChat(Provider):
         is_conversation: bool = True,
         max_tokens: int = 600,
         timeout: int = 30,
+        temperature: float = 1,
         intro: str = None,
         filepath: str = None,
+        top_p: float = 0.95,
         update_file: bool = True,
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "o1-preview",  # Default model
+        model: str = "Qwen/Qwen2.5-72B-Instruct-Turbo",  # Default model
         system_prompt: str = "You are a helpful and friendly AI assistant.",
     ):
         """
@@ -68,8 +75,10 @@ class AmigoChat(Provider):
         self.api_endpoint = "https://api.amigochat.io/v1/chat/completions"
         self.stream_chunk_size = 64
         self.timeout = timeout
+        self.temperature = temperature
         self.last_response = {}
         self.model = model
+        self.top_p = top_p
         self.headers = {
             "Accept": "*/*",
             "Accept-Encoding": "gzip, deflate, br, zstd",
@@ -158,11 +167,11 @@ class AmigoChat(Provider):
             ],
             "model": self.model,
             "frequency_penalty": 0,
-            "max_tokens": 4000,
+            "max_tokens": self.max_tokens_to_sample,
             "presence_penalty": 0,
             "stream": stream,
-            "temperature": 0.5,
-            "top_p": 0.95
+            "temperature":self.temperature,
+            "top_p": self.top_p
         }
 
         def for_stream():

webscout/Provider/Andi.py

@@ -92,40 +92,7 @@ class AndiSearch(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> dict:
-        """Chat with AI
 
-        Args:
-            prompt (str): Prompt to be send.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-        Returns:
-           dict : {}
-        ```json
-        {
-            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
-            "object": "chat.completion",
-            "created": 1704623244,
-            "model": "gpt-3.5-turbo",
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-                },
-            "choices": [
-                {
-                    "message": {
-                        "role": "assistant",
-                        "content": "Hello! How can I assist you today?"
-                },
-                "finish_reason": "stop",
-                "index": 0
-                }
-            ]
-        }
-        ```
-        """
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers: