webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Provider/TextPollinationsAI.py

@@ -1,44 +1,41 @@
-import requests
 import json
-from typing import Union, Any, Dict, Generator
-from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
-from webscout.AIbase import Provider
+from typing import Any, Dict, Generator, List, Optional, Union, cast
+
+import requests
+
 from webscout import exceptions
+from webscout.AIbase import Provider, Response
+from webscout.AIutel import AwesomePrompts, Conversation, Optimizers, sanitize_stream
 from webscout.litagent import LitAgent as Lit
 
+
 class TextPollinationsAI(Provider):
     """
     A class to interact with the Pollinations AI API.
     """
 
+    required_auth = False
+    _models_url = "https://text.pollinations.ai/models"
+
+    # Static list as fallback
     AVAILABLE_MODELS = [
+        "deepseek",
+        "gemini",
+        "gemini-search",
+        "mistral",
         "openai",
+        "openai-audio",
+        "openai-fast",
         "openai-large",
         "openai-reasoning",
         "qwen-coder",
-        "llama",
-        "llamascout",
-        "mistral",
-        "unity",
+        "roblox-rp",
+        "bidara",
+        "chickytutor",
+        "evil",
         "midijourney",
         "rtist",
-        "searchgpt",
-        "evil",
-        "deepseek-reasoning",
-        "deepseek-reasoning-large",
-        "llamalight",
-        "phi",
-        "llama-vision",
-        "pixtral",
-        "gemini",
-        "hormoz",
-        "hypnosis-tracy",
-        "mistral-roblox",
-        "roblox-rp",
-        "deepseek",
-        "sur",
-        "llama-scaleway",
-        "openai-audio",
+        "unity",
     ]
 
     def __init__(
@@ -46,65 +43,95 @@ class TextPollinationsAI(Provider):
         is_conversation: bool = True,
         max_tokens: int = 8096,
         timeout: int = 30,
-        intro: str = None,
-        filepath: str = None,
+        intro: Optional[str] = None,
+        filepath: Optional[str] = None,
         update_file: bool = True,
         proxies: dict = {},
         history_offset: int = 10250,
-        act: str = None,
-        model: str = "openai-large",
+        act: Optional[str] = None,
+        model: str = "openai",
         system_prompt: str = "You are a helpful AI assistant.",
     ):
         """Initializes the TextPollinationsAI API client."""
-        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
         self.api_endpoint = "https://text.pollinations.ai/openai"
-        self.stream_chunk_size = 64
         self.timeout = timeout
         self.last_response = {}
         self.model = model
         self.system_prompt = system_prompt
-        
+        self.proxies = proxies
+
+        # Fetch latest models dynamically to ensure we have the most up-to-date list
+        self.update_available_models()
+
+        if model not in self.AVAILABLE_MODELS:
+            # warn or just allow it? allowing it for flexibility
+            if model not in self.AVAILABLE_MODELS:
+                pass  # User might know a model we don't
+
         self.headers = {
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'User-Agent': Lit().random(),
-            'Content-Type': 'application/json',
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+            "User-Agent": Lit().random(),
+            "Content-Type": "application/json",
         }
-        
+
         self.session.headers.update(self.headers)
-        self.session.proxies = proxies
+        if proxies:
+            self.session.proxies.update(proxies)
 
         self.__available_optimizers = (
-            method for method in dir(Optimizers)
+            method
+            for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
 
-        Conversation.intro = (
-            AwesomePrompts().get_act(
-                act, raise_not_found=True, default=None, case_insensitive=True
-            )
-            if act
-            else intro or Conversation.intro
-        )
-
         self.conversation = Conversation(
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
 
+        if act:
+            self.conversation.intro = (
+                AwesomePrompts().get_act(
+                    cast(Union[str, int], act),
+                    default=self.conversation.intro,
+                    case_insensitive=True,
+                )
+                or self.conversation.intro
+            )
+        elif intro:
+            self.conversation.intro = intro
+
+    def update_available_models(self):
+        try:
+            response = requests.get(
+                self._models_url, headers={"Accept": "application/json"}, timeout=10
+            )
+            if response.status_code == 200:
+                data = response.json()
+                if isinstance(data, list):
+                    new_models = [
+                        m.get("name") for m in data if isinstance(m, dict) and "name" in m
+                    ]
+                    if new_models:
+                        self.AVAILABLE_MODELS = new_models
+        except Exception:
+            pass
+
     def ask(
         self,
         prompt: str,
         stream: bool = False,
         raw: bool = False,
-        optimizer: str = None,
+        optimizer: Optional[str] = None,
         conversationally: bool = False,
-    ) -> Union[Dict[str, Any], Generator[Any, None, None]]:
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Response:
         """Chat with AI"""
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -118,55 +145,107 @@ class TextPollinationsAI(Provider):
         payload = {
             "messages": [
                 {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": conversation_prompt}
+                {"role": "user", "content": conversation_prompt},
             ],
             "model": self.model,
             "stream": stream,
         }
 
+        if tools:
+            payload["tools"] = tools
+        if tool_choice:
+            payload["tool_choice"] = tool_choice
+
         def for_stream():
-            response = self.session.post(
-                self.api_endpoint,
-                headers=self.headers,
-                json=payload,
-                stream=True,
-                timeout=self.timeout
-            )
+            try:
+                response = self.session.post(
+                    self.api_endpoint, json=payload, stream=True, timeout=self.timeout
+                )
+                response.raise_for_status()
 
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                streaming_text = ""
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None),
+                    intro_value="data:",  # Standard OpenAI SSE prefix
+                    to_json=True,
+                    skip_markers=["[DONE]"],
+                    content_extractor=lambda chunk: chunk.get("choices", [{}])[0].get("delta")
+                    if isinstance(chunk, dict)
+                    else None,
+                    yield_raw_on_error=False,
+                    raw=raw,
                 )
 
-            full_response = ""
-            for line in response.iter_lines():
-                if line:
-                    line = line.decode('utf-8').strip()
-                    if line == "data: [DONE]":
-                        break
-                    if line.startswith('data: '):
-                        try:
-                            json_data = json.loads(line[6:])
-                            if 'choices' in json_data and len(json_data['choices']) > 0:
-                                choice = json_data['choices'][0]
-                                if 'delta' in choice and 'content' in choice['delta']:
-                                    content = choice['delta']['content']
-                                else:
-                                    content = ""
-                                full_response += content
-                                yield content if raw else dict(text=content)
-                        except json.JSONDecodeError:
-                            continue
-
-            self.last_response.update(dict(text=full_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                for delta in processed_stream:
+                    if isinstance(delta, dict):
+                        # Extract content if available
+                        if "content" in delta and delta["content"] is not None:
+                            content = delta["content"]
+                            if raw:
+                                yield content
+                            else:
+                                streaming_text += content
+                                yield dict(text=content)
+                        # Extract tool calls if available
+                        elif "tool_calls" in delta:
+                            tool_calls = delta["tool_calls"]
+                            if raw:
+                                yield json.dumps(tool_calls)
+                            else:
+                                yield dict(tool_calls=tool_calls)
+
+                self.last_response = {"text": streaming_text}
+                if streaming_text:
+                    self.conversation.update_chat_history(prompt, streaming_text)
+
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Stream request failed: {e}") from e
 
         def for_non_stream():
-            for _ in for_stream():
-                pass
-            return self.last_response
+            try:
+                # Force stream=False for non-streaming request
+                payload["stream"] = False
+                response = self.session.post(self.api_endpoint, json=payload, timeout=self.timeout)
+                response.raise_for_status()
+
+                # Use sanitize_stream to parse the non-streaming JSON response
+                processed_stream = sanitize_stream(
+                    data=response.text,
+                    to_json=True,
+                    intro_value=None,
+                    content_extractor=lambda chunk: chunk if isinstance(chunk, dict) else None,
+                    yield_raw_on_error=False,
+                )
+                # Extract the single result
+                resp_json = next(processed_stream, None)
+
+                # Check for standard OpenAI response structure
+                if resp_json and "choices" in resp_json and len(resp_json["choices"]) > 0:
+                    choice = resp_json["choices"][0]
+                    content = choice.get("message", {}).get("content")
+                    tool_calls = choice.get("message", {}).get("tool_calls")
+                    result = content if content else (tool_calls if tool_calls else "")
+
+                    self.last_response = (
+                        {"text": content or ""}
+                        if content
+                        else ({"tool_calls": tool_calls} if tool_calls else {})
+                    )
+                    self.conversation.update_chat_history(prompt, content or "")
+
+                    if raw:
+                        return (
+                            content if content else (json.dumps(tool_calls) if tool_calls else "")
+                        )
+                    return result
+
+                else:
+                    return {}
+
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Non-stream request failed: {e}"
+                ) from e
 
         return for_stream() if stream else for_non_stream()
 
@@ -174,58 +253,79 @@ class TextPollinationsAI(Provider):
         self,
         prompt: str,
         stream: bool = False,
-        optimizer: str = None,
+        optimizer: Optional[str] = None,
         conversationally: bool = False,
+        **kwargs: Any,
     ) -> Union[str, Generator[str, None, None]]:
-        """Generate response as a string"""
+        raw = kwargs.get("raw", False)
+        tools = kwargs.get("tools")
+        tool_choice = kwargs.get("tool_choice")
+
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt,
+                True,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                tools=tools,
+                tool_choice=tool_choice,
             ):
-                yield self.get_message(response)
+                if raw:
+                    yield cast(str, response)
+                else:
+                    yield self.get_message(cast(Dict[str, Any], response))
 
         def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                tools=tools,
+                tool_choice=tool_choice,
             )
+            if raw:
+                return cast(str, result)
+            return self.get_message(cast(Dict[str, Any], result))
 
         return for_stream() if stream else for_non_stream()
 
-    def get_message(self, response: dict) -> str:
+    def get_message(self, response: Response) -> str:
         """Retrieves message only from response"""
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        if not isinstance(response, dict):
+            return str(response)
+        if "text" in response:
+            return response["text"]
+        elif "tool_calls" in response:
+            return json.dumps(response["tool_calls"])
+        return ""
+
 
 if __name__ == "__main__":
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
-    
-    # Test all available models
-    working = 0
-    total = len(TextPollinationsAI.AVAILABLE_MODELS)
-    
-    for model in TextPollinationsAI.AVAILABLE_MODELS:
+
+    # Test only a subset to be fast
+    test_models = ["openai", "gemini"]
+
+    for model in test_models:
         try:
+            print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
             test_ai = TextPollinationsAI(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:
+
+            # Non-stream test
+            start_response = test_ai.chat("Hello!", stream=False)
+            if start_response and isinstance(start_response, str):
                 status = "✓"
-                # Truncate response if too long
-                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+                display = start_response[:30] + "..."
             else:
                 status = "✗"
-                display_text = "Empty or invalid response"
-            print(f"\r{model:<50} {status:<10} {display_text}")
+                display = "Empty or invalid type"
+
+            print(f"\r{model:<50} {status:<10} {display}")
+
         except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")
+            print(f"\r{model:<50} {'✗':<10} {str(e)[:50]}")