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

webscout/Provider/OLLAMA.py

@@ -3,8 +3,12 @@ from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts, sanitize_stream
 from webscout.AIbase import Provider, AsyncProvider
 from webscout import exceptions
-from typing import Any, AsyncGenerator, Dict
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union
 import ollama
+from ollama import AsyncClient, Client, ResponseError
+import asyncio
+import base64
+from pathlib import Path
 
 class OLLAMA(Provider):
     def __init__(
@@ -19,7 +23,9 @@ class OLLAMA(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        system_prompt: str = "You are a helpful and friendly AI assistant.", 
+        system_prompt: str = "You are a helpful and friendly AI assistant.",
+        host: str = 'http://localhost:11434',
+        headers: Optional[Dict] = None,
     ):
         """Instantiates Ollama
 
@@ -34,7 +40,9 @@ class OLLAMA(Provider):
             proxies (dict, optional): Http request proxies. Defaults to {}.
             history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
-            system_prompt (str, optional): System prompt for Ollama. Defaults to "You are a helpful and friendly AI assistant.". 
+            system_prompt (str, optional): System prompt for Ollama. Defaults to "You are a helpful and friendly AI assistant.".
+            host (str, optional): Ollama host URL. Defaults to 'http://localhost:11434'.
+            headers (dict, optional): Custom headers for requests. Defaults to None.
         """
         self.model = model
         self.is_conversation = is_conversation
@@ -42,6 +50,8 @@ class OLLAMA(Provider):
         self.timeout = timeout
         self.last_response = {}
         self.system_prompt = system_prompt
+        self.client = Client(host=host, headers=headers)
+        self.async_client = AsyncClient(host=host, headers=headers)
 
         self.__available_optimizers = (
             method
@@ -67,6 +77,8 @@ class OLLAMA(Provider):
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        tools: Optional[List[Dict]] = None,
+        images: Optional[List[str]] = None,
     ) -> dict | AsyncGenerator:
         """Chat with AI
 
@@ -76,13 +88,10 @@ class OLLAMA(Provider):
             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.
+            tools (List[Dict], optional): List of tools/functions to use. Defaults to None.
+            images (List[str], optional): List of image paths or base64 encoded images. Defaults to None.
         Returns:
            dict|AsyncGenerator : ai content
-        ```json
-        {
-           "text" : "print('How may I help you today?')"
-        }
-        ```
         """
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -95,29 +104,101 @@ class OLLAMA(Provider):
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
 
-        def for_stream():
-            # Correctly call ollama.chat with stream=True
-            stream = ollama.chat(model=self.model, messages=[
-                {'role': 'system', 'content': self.system_prompt}, 
-                {'role': 'user', 'content': conversation_prompt}
-            ], stream=True)
+        messages = [
+            {'role': 'system', 'content': self.system_prompt},
+            {'role': 'user', 'content': conversation_prompt}
+        ]
 
-            # Yield each chunk directly
-            for chunk in stream:
-                yield chunk['message']['content'] if raw else dict(text=chunk['message']['content'])
+        if images:
+            messages[-1]['images'] = images
 
-        def for_non_stream():
-            response = ollama.chat(model=self.model, messages=[
-                {'role': 'system', 'content': self.system_prompt}, # Add system message
-                {'role': 'user', 'content': conversation_prompt}
-            ])
-            self.last_response.update(dict(text=response['message']['content']))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
-            return self.last_response
+        try:
+            def for_stream():
+                stream = self.client.chat(
+                    model=self.model,
+                    messages=messages,
+                    stream=True,
+                    tools=tools
+                )
+                for chunk in stream:
+                    yield chunk['message']['content'] if raw else dict(text=chunk['message']['content'])
 
-        return for_stream() if stream else for_non_stream()
+            def for_non_stream():
+                response = self.client.chat(
+                    model=self.model,
+                    messages=messages,
+                    tools=tools
+                )
+                self.last_response.update(dict(text=response['message']['content']))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+                return self.last_response
+
+            return for_stream() if stream else for_non_stream()
+        except ResponseError as e:
+            if e.status_code == 404:
+                raise Exception(f"Model {self.model} not found. Please pull it first using `ollama pull {self.model}`")
+            raise e
+
+    async def aask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        tools: Optional[List[Dict]] = None,
+        images: Optional[List[str]] = None,
+    ) -> dict | AsyncGenerator:
+        """Async version of ask method"""
+        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
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        messages = [
+            {'role': 'system', 'content': self.system_prompt},
+            {'role': 'user', 'content': conversation_prompt}
+        ]
+
+        if images:
+            messages[-1]['images'] = images
+
+        try:
+            async def for_stream():
+                stream = await self.async_client.chat(
+                    model=self.model,
+                    messages=messages,
+                    stream=True,
+                    tools=tools
+                )
+                async for chunk in stream:
+                    yield chunk['message']['content'] if raw else dict(text=chunk['message']['content'])
+
+            async def for_non_stream():
+                response = await self.async_client.chat(
+                    model=self.model,
+                    messages=messages,
+                    tools=tools
+                )
+                self.last_response.update(dict(text=response['message']['content']))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+                return self.last_response
+
+            return for_stream() if stream else for_non_stream()
+        except ResponseError as e:
+            if e.status_code == 404:
+                raise Exception(f"Model {self.model} not found. Please pull it first using `ollama pull {self.model}`")
+            raise e
 
     def chat(
         self,
@@ -125,6 +206,8 @@ class OLLAMA(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        tools: Optional[List[Dict]] = None,
+        images: Optional[List[str]] = None,
     ) -> str | AsyncGenerator:
         """Generate response `str`
         Args:
@@ -132,13 +215,15 @@ class OLLAMA(Provider):
             stream (bool, optional): Flag for streaming response. 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.
+            tools (List[Dict], optional): List of tools/functions to use. Defaults to None.
+            images (List[str], optional): List of image paths or base64 encoded images. Defaults to None.
         Returns:
             str: Response generated
         """
-
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt, True, optimizer=optimizer, conversationally=conversationally,
+                tools=tools, images=images
             ):
                 yield self.get_message(response)
 
@@ -149,6 +234,39 @@ class OLLAMA(Provider):
                     False,
                     optimizer=optimizer,
                     conversationally=conversationally,
+                    tools=tools,
+                    images=images
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    async def achat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        tools: Optional[List[Dict]] = None,
+        images: Optional[List[str]] = None,
+    ) -> str | AsyncGenerator:
+        """Async version of chat method"""
+        async def for_stream():
+            async for response in await self.aask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally,
+                tools=tools, images=images
+            ):
+                yield self.get_message(response)
+
+        async def for_non_stream():
+            return self.get_message(
+                await self.aask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                    tools=tools,
+                    images=images
                 )
             )
 
@@ -165,8 +283,114 @@ class OLLAMA(Provider):
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
         return response["text"]
+
+    def generate(
+        self,
+        prompt: str,
+        stream: bool = False,
+        **kwargs
+    ) -> dict | AsyncGenerator:
+        """Generate text using the model"""
+        try:
+            if stream:
+                return self.client.generate(model=self.model, prompt=prompt, stream=True, **kwargs)
+            return self.client.generate(model=self.model, prompt=prompt, **kwargs)
+        except ResponseError as e:
+            if e.status_code == 404:
+                raise Exception(f"Model {self.model} not found. Please pull it first using `ollama pull {self.model}`")
+            raise e
+
+    async def agenerate(
+        self,
+        prompt: str,
+        stream: bool = False,
+        **kwargs
+    ) -> dict | AsyncGenerator:
+        """Async version of generate method"""
+        try:
+            if stream:
+                return await self.async_client.generate(model=self.model, prompt=prompt, stream=True, **kwargs)
+            return await self.async_client.generate(model=self.model, prompt=prompt, **kwargs)
+        except ResponseError as e:
+            if e.status_code == 404:
+                raise Exception(f"Model {self.model} not found. Please pull it first using `ollama pull {self.model}`")
+            raise e
+
+    def list_models(self) -> List[dict]:
+        """List all available models"""
+        return self.client.list()
+
+    def show_model(self, model: str = None) -> dict:
+        """Show model details"""
+        model = model or self.model
+        return self.client.show(model)
+
+    def pull_model(self, model: str = None) -> None:
+        """Pull a model from Ollama"""
+        model = model or self.model
+        self.client.pull(model)
+
+    def delete_model(self, model: str = None) -> None:
+        """Delete a model"""
+        model = model or self.model
+        self.client.delete(model)
+
+    def embed(
+        self,
+        input: Union[str, List[str]],
+        model: str = None
+    ) -> List[float]:
+        """Generate embeddings for input text"""
+        model = model or self.model
+        return self.client.embed(model=model, input=input)
+
+    async def aembed(
+        self,
+        input: Union[str, List[str]],
+        model: str = None
+    ) -> List[float]:
+        """Async version of embed method"""
+        model = model or self.model
+        return await self.async_client.embed(model=model, input=input)
+
 if __name__ == "__main__":
-    ai = OLLAMA(model="llama3.2:1b")
+    # Example usage
+    ai = OLLAMA(model="qwen2.5:0.5b")
+    # ai.pull_model("qwen2.5:0.5b")
+    # Basic chat
     response = ai.chat("write a poem about AI", stream=True)
     for chunk in response:
-        print(chunk, end="", flush=True)
+        print(chunk, end="", flush=True)
+    
+    # Vision example
+    # response = ai.chat(
+    #     "What's in this image?",
+    #     images=["path/to/image.jpg"]
+    # )
+    # print(response)
+    
+    # Tools example
+    def add_numbers(a: int, b: int) -> int:
+        return a + b
+    
+    tools = [{
+        'type': 'function',
+        'function': {
+            'name': 'add_numbers',
+            'description': 'Add two numbers',
+            'parameters': {
+                'type': 'object',
+                'properties': {
+                    'a': {'type': 'integer'},
+                    'b': {'type': 'integer'}
+                },
+                'required': ['a', 'b']
+            }
+        }
+    }]
+    
+    response = ai.chat(
+        "What is 5 plus 3?",
+        tools=tools
+    )
+    print(response)

webscout/Provider/PI.py

@@ -18,8 +18,9 @@ class PiAI(Provider):
     Attributes:
         knowledge_cutoff (str): The knowledge cutoff date for the model
         AVAILABLE_VOICES (Dict[str, int]): Available voice options for audio responses
+        AVAILABLE_MODELS (List[str]): Available model options for the API
     """
-
+    AVAILABLE_MODELS = ["inflection_3_pi"]
     AVAILABLE_VOICES: Dict[str, int] = {
         "voice1": 1,
         "voice2": 2,
@@ -44,7 +45,8 @@ class PiAI(Provider):
         act: str = None,
         voice: bool = False,
         voice_name: str = "voice3",
-        output_file: str = "PiAI.mp3"
+        output_file: str = "PiAI.mp3",
+        model: str = "inflection_3_pi",
     ):
         """
         Initializes PiAI with voice support.

webscout/Provider/Perplexitylabs.py

@@ -386,10 +386,30 @@ class PerplexityLabs(Provider):
 
 
 if __name__ == "__main__":
-    from rich import print
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
     
-    # Example usage
-    ai = PerplexityLabs(timeout=60, model="r1-1776")
-
-    for chunk in ai.chat("Explain the concept of neural networks", stream=True):
-        print(chunk, end="", flush=True)
+    # Test all available models
+    working = 0
+    total = len(PerplexityLabs.AVAILABLE_MODELS)
+    
+    for model in PerplexityLabs.AVAILABLE_MODELS:
+        try:
+            test_ai = PerplexityLabs(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)}")

webscout/Provider/PizzaGPT.py

@@ -6,14 +6,14 @@ from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout import LitAgent as Lit
-from webscout.Litlogger import Logger, LogFormat
 
 class PIZZAGPT(Provider):
     """
     PIZZAGPT is a provider class for interacting with the PizzaGPT API.
     Supports web search integration and handles responses using regex.
     """
-
+    AVAILABLE_MODELS = ["gpt-4o-mini"]
+    
     def __init__(
         self,
         is_conversation: bool = True,
@@ -25,10 +25,12 @@ class PIZZAGPT(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        logging: bool = False,
         model: str = "gpt-4o-mini"
     ) -> None:
         """Initialize PizzaGPT with enhanced configuration options."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            
         self.session = requests.Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -45,7 +47,9 @@ class PIZZAGPT(Provider):
             "origin": "https://www.pizzagpt.it",
             "referer": "https://www.pizzagpt.it/en",
             "user-agent": Lit().random(),
-            "x-secret": "Marinara"
+            "x-secret": "Marinara",
+            "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24"',
+            "sec-ch-ua-platform": '"Windows"'
         }
 
         self.__available_optimizers = (
@@ -67,28 +71,15 @@ class PIZZAGPT(Provider):
         )
         self.conversation.history_offset = history_offset
         self.session.proxies = proxies
-        
-        self.logger = Logger(
-            name="PIZZAGPT",
-            format=LogFormat.MODERN_EMOJI,
-        ) if logging else None
-
-        if self.logger:
-            self.logger.info(f"PIZZAGPT initialized with model: {self.model}")
 
     def _extract_content(self, text: str) -> Dict[str, Any]:
         """
         Extract content from response text using regex.
         """
-        if self.logger:
-            self.logger.debug("Extracting content from response text")
-            
         try:
             # Look for content pattern
             content_match = re.search(r'"content"\s*:\s*"(.*?)"(?=\s*[,}])', text, re.DOTALL)
             if not content_match:
-                if self.logger:
-                    self.logger.error("Content pattern not found in response")
                 raise exceptions.FailedToGenerateResponseError("Content not found in response")
                 
             content = content_match.group(1)
@@ -108,8 +99,6 @@ class PIZZAGPT(Provider):
             }
             
         except Exception as e:
-            if self.logger:
-                self.logger.error(f"Failed to extract content: {str(e)}")
             raise exceptions.FailedToGenerateResponseError(f"Failed to extract content: {str(e)}")
 
     def ask(
@@ -124,21 +113,13 @@ class PIZZAGPT(Provider):
         """
         Send a prompt to PizzaGPT API with optional web search capability.
         """
-        if self.logger:
-            self.logger.debug(f"Processing request - Prompt: {prompt[:50]}...")
-            self.logger.debug(f"Web search enabled: {web_search}")
-
         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: {optimizer}")
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
         payload = {
@@ -147,9 +128,6 @@ class PIZZAGPT(Provider):
             "searchEnabled": web_search
         }
 
-        if self.logger:
-            self.logger.debug(f"Sending payload: {json.dumps(payload, indent=2)}")
-
         try:
             response = self.session.post(
                 self.api_endpoint,
@@ -157,26 +135,17 @@ class PIZZAGPT(Provider):
                 timeout=self.timeout
             )
             
-            if self.logger:
-                self.logger.debug(f"Response status: {response.status_code}")
-            
             if not response.ok:
-                if self.logger:
-                    self.logger.error(f"API request failed: {response.status_code} - {response.reason}")
                 raise exceptions.FailedToGenerateResponseError(
                     f"Failed to generate response - ({response.status_code}, {response.reason})"
                 )
 
             response_text = response.text
             if not response_text:
-                if self.logger:
-                    self.logger.error("Empty response received from API")
                 raise exceptions.FailedToGenerateResponseError("Empty response received from API")
 
             try:
                 resp = self._extract_content(response_text)
-                if self.logger:
-                    self.logger.debug("Response parsed successfully")
                     
                 self.last_response.update(dict(text=resp['content']))
                 self.conversation.update_chat_history(
@@ -185,14 +154,9 @@ class PIZZAGPT(Provider):
                 return self.last_response
 
             except Exception as e:
-                if self.logger:
-                    self.logger.error(f"Failed to parse response: {str(e)}")
-                    self.logger.debug(f"Raw response text: {response_text[:500]}")
                 raise exceptions.FailedToGenerateResponseError(f"Failed to parse response: {str(e)}")
 
         except requests.exceptions.RequestException as e:
-            if self.logger:
-                self.logger.error(f"Request failed: {str(e)}")
             raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
 
     def chat(
@@ -206,9 +170,6 @@ class PIZZAGPT(Provider):
         """
         Chat with PizzaGPT with optional web search capability.
         """
-        if self.logger:
-            self.logger.debug(f"Chat request initiated with web_search={web_search}")
-            
         try:
             response = self.ask(
                 prompt,
@@ -218,8 +179,6 @@ class PIZZAGPT(Provider):
             )
             return self.get_message(response)
         except Exception as e:
-            if self.logger:
-                self.logger.error(f"Chat failed: {str(e)}")
             raise
 
     def get_message(self, response: dict) -> str:
@@ -231,9 +190,9 @@ if __name__ == "__main__":
     from rich import print
     
     # Example usage with web search enabled
-    ai = PIZZAGPT(logging=True)
+    ai = PIZZAGPT()
     try:
-        response = ai.chat("Who is Founder and CEO of HelpingAI??", web_search=True)
+        response = ai.chat("hi")
         print(response)
     except Exception as e:
         print(f"Error: {str(e)}")