webscout 8.3.2__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/Provider/OpenGPT.py

@@ -87,7 +87,7 @@ class OpenGPT(Provider):
     def ask(
         self,
         prompt: str,
-        stream: bool = False, # Note: API does not support streaming
+        stream: bool = False, # Note: API does not support streaming natively
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
@@ -121,38 +121,54 @@ class OpenGPT(Provider):
             "id": self.app_id,
             "userKey": ""  # Assuming userKey is meant to be empty as in the original code
         }
-        
-        # API does not stream, implement non-stream logic directly
+
+        def for_stream():
+            try:
+                response = self.session.post(
+                    "https://open-gpt.app/api/generate",
+                    data=json.dumps(payload),
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+                response.raise_for_status()
+                response_text = response.text
+                buffer = ""
+                chunk_size = 32
+                for i in range(0, len(response_text), chunk_size):
+                    out = response_text[i:i+chunk_size]
+                    if out.strip():
+                        if raw:
+                            yield out
+                        else:
+                            yield {"text": out}
+                self.last_response = {"text": response_text}
+                self.conversation.update_chat_history(prompt, response_text)
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+            except Exception as e:
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
+
         def for_non_stream():
             try:
-                # Use curl_cffi session post with impersonate
                 response = self.session.post(
                     "https://open-gpt.app/api/generate",
-                    # headers are set on the session
-                    data=json.dumps(payload), # Keep data as JSON string
+                    data=json.dumps(payload),
                     timeout=self.timeout,
-                    # proxies are set on the session
-                    impersonate="chrome110" # Use a common impersonation profile
+                    impersonate="chrome110"
                 )
-                
-                response.raise_for_status() # Check for HTTP errors
-                
-                # Use response.text which is already decoded
+                response.raise_for_status()
                 response_text = response.text
                 self.last_response = {"text": response_text}
                 self.conversation.update_chat_history(prompt, response_text)
-                
-                # Return dict or raw string based on raw flag
                 return {"raw": response_text} if raw else {"text": response_text}
-                
-            except CurlError as e: # Catch CurlError
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
-            except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
+            except Exception as e:
                 err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
-        
-        # This provider doesn't support streaming, so just return non-stream
-        return for_non_stream()
+
+        return for_stream() if stream else for_non_stream()
 
     def chat(
         self,
@@ -173,21 +189,25 @@ class OpenGPT(Provider):
         Returns:
             A string with the response text.
         """
-        # Since ask() now handles both stream=True/False by returning the full response dict:
-        response_data = self.ask(
-            prompt, 
-            stream=False, # Call ask in non-stream mode internally
-            raw=False, # Ensure ask returns dict with 'text' key
-            optimizer=optimizer, 
-            conversationally=conversationally
-        )
-        # If stream=True was requested, simulate streaming by yielding the full message at once
         if stream:
             def stream_wrapper():
-                yield self.get_message(response_data)  # yield only the text string
+                for part in self.ask(
+                    prompt,
+                    stream=True,
+                    raw=False,
+                    optimizer=optimizer,
+                    conversationally=conversationally
+                ):
+                    yield self.get_message(part) if isinstance(part, dict) else part
             return stream_wrapper()
         else:
-            # If stream=False, return the full message directly
+            response_data = self.ask(
+                prompt,
+                stream=False,
+                raw=False,
+                optimizer=optimizer,
+                conversationally=conversationally
+            )
             return self.get_message(response_data)
 
     def get_message(self, response: dict) -> str:
@@ -206,4 +226,6 @@ class OpenGPT(Provider):
 
 if __name__ == "__main__":
     ai = OpenGPT()
-    print(ai.chat("Hello, how are you?"))
+    response = ai.chat("write me about humans in points", stream=True)
+    for part in response:
+        print(part, end="", flush=True)

webscout/Provider/PI.py

@@ -172,9 +172,10 @@ class PiAI(Provider):
         voice: bool = None,
         voice_name: str = None,
         output_file: str = None
-    ) -> dict:
+    ) -> Union[dict, str, Any]:
         """
         Interact with Pi.ai by sending a prompt and receiving a response.
+        Now supports raw streaming and non-streaming output, matching the pattern in other providers.
 
         Args:
             prompt (str): The prompt to send
@@ -209,103 +210,82 @@ class PiAI(Provider):
         }
 
         def process_stream():
-            try: # Add outer try block for error handling
-                # Try primary URL first
+            try:
                 current_url = self.url
                 response = self.session.post(
                     current_url,
-                    # headers are set on the session
-                    # cookies are handled by the session
                     json=data,
                     stream=True,
                     timeout=self.timeout,
-                    # proxies are set on the session
-                    impersonate="chrome110" # Use a common impersonation profile
+                    impersonate="chrome110"
                 )
-
-                # If primary URL fails, try fallback URL
                 if not response.ok and current_url == self.primary_url:
                     current_url = self.fallback_url
                     response = self.session.post(
                         current_url,
-                        # headers are set on the session
-                        # cookies are handled by the session
                         json=data,
                         stream=True,
                         timeout=self.timeout,
-                        # proxies are set on the session
-                        impersonate="chrome110" # Use a common impersonation profile
+                        impersonate="chrome110"
                     )
-
-                response.raise_for_status() # Check for HTTP errors after potential fallback
-
-                # --- Process response content ---
-                # Note: curl_cffi's response.content might behave differently for streams.
-                # It's often better to iterate directly.
-                # output_str = response.content.decode('utf-8') # Avoid reading full content at once for streams
+                response.raise_for_status()
 
                 sids = []
                 streaming_text = ""
-                full_raw_data_for_sids = "" # Accumulate raw data to find SIDs later
-
-                # Iterate over bytes and decode manually
+                full_raw_data_for_sids = ""
+
+                processed_stream = sanitize_stream(
+                    data=response.iter_lines(),
+                    intro_value="data: ",
+                    to_json=True,
+                    content_extractor=self._pi_extractor,
+                    raw=raw
+                )
+                for content in processed_stream:
+                    if raw:
+                        yield content
+                    else:
+                        if content and isinstance(content, str):
+                            streaming_text += content
+                            yield {"text": streaming_text}
+                # SID extraction for voice
                 for line_bytes in response.iter_lines():
                     if line_bytes:
                         line = line_bytes.decode('utf-8')
-                        full_raw_data_for_sids += line + "\n" # Accumulate for SID extraction
-                        
-                        if line.startswith("data: "):
-                            json_line_str = line[6:] # Get the JSON part as string
-                            try:
-                                # Process this single JSON line string with sanitize_stream
-                                processed_gen = sanitize_stream(
-                                    data=json_line_str,
-                                    to_json=True,
-                                    content_extractor=self._pi_extractor
-                                )
-                                chunk_text = next(processed_gen, None) # Get the single extracted text item
-                                if chunk_text and isinstance(chunk_text, str):
-                                    streaming_text += chunk_text
-                                    yield {"text": streaming_text} # Always yield dict with aggregated text
-                            except (StopIteration, json.JSONDecodeError, UnicodeDecodeError):
-                                continue # Skip if sanitize_stream fails or yields nothing
-                # Extract SIDs after processing the stream
+                        full_raw_data_for_sids += line + "\n"
                 sids = re.findall(r'"sid":"(.*?)"', full_raw_data_for_sids)
                 second_sid = sids[1] if len(sids) >= 2 else None
-
                 if voice and voice_name and second_sid:
                     threading.Thread(
                         target=self.download_audio_threaded,
                         args=(voice_name, second_sid, output_file)
                     ).start()
-
-                # Update history and last response after stream finishes
-                self.last_response = dict(text=streaming_text)
-                self.conversation.update_chat_history(
-                    prompt, streaming_text
-                )
-
-            except CurlError as e: # Catch CurlError
+                if not raw:
+                    self.last_response = dict(text=streaming_text)
+                    self.conversation.update_chat_history(prompt, streaming_text)
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"API request failed (CurlError): {e}") from e
-            except Exception as e: # Catch other potential exceptions (like HTTPError)
+            except Exception as e:
                 err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
                 raise exceptions.FailedToGenerateResponseError(f"API request failed ({type(e).__name__}): {e} - {err_text}") from e
 
-
         if stream:
             return process_stream()
         else:
-            # For non-stream, collect all responses and return the final one
-            final_text = ""
-            # process_stream always yields dicts now
-            for res in process_stream():
-                 if isinstance(res, dict) and "text" in res:
-                     final_text = res["text"] # Keep updating with the latest aggregated text
-
-            # last_response and history are updated within process_stream
-            # Return the final aggregated response dict or raw text
-            return final_text if raw else self.last_response
-
+            full_response = ""
+            for chunk in process_stream():
+                if raw:
+                    if isinstance(chunk, str):
+                        full_response += chunk
+                else:
+                    if isinstance(chunk, dict) and "text" in chunk:
+                        full_response = chunk["text"]
+            if not raw:
+                self.last_response = {"text": full_response}
+                self.conversation.update_chat_history(prompt, full_response)
+                return self.last_response
+            else:
+                return full_response
 
     def chat(
         self,
@@ -315,8 +295,9 @@ class PiAI(Provider):
         conversationally: bool = False,
         voice: bool = None,
         voice_name: str = None,
-        output_file: str = None
-    ) -> str:
+        output_file: str = None,
+        raw: bool = False,  # Added raw parameter
+    ) -> Union[str, Any]:
         """
         Generates a response based on the provided prompt.
 
@@ -339,35 +320,37 @@ class PiAI(Provider):
 
         if stream:
             def stream_generator():
-                # ask() yields dicts or raw JSON objects when streaming
                 gen = self.ask(
                     prompt,
                     stream=True,
-                    raw=False, # Ensure ask yields dicts for get_message
+                    raw=raw,
                     optimizer=optimizer,
                     conversationally=conversationally,
                     voice=voice,
                     voice_name=voice_name,
                     output_file=output_file
                 )
-                for response_dict in gen:
-                    # get_message expects dict
-                    yield self.get_message(response_dict) 
+                for response in gen:
+                    if raw:
+                        yield response
+                    else:
+                        yield self.get_message(response)
             return stream_generator()
         else:
-            # ask() returns dict or raw text when not streaming
             response_data = self.ask(
                 prompt,
                 stream=False,
-                raw=False, # Ensure ask returns dict for get_message
+                raw=raw,
                 optimizer=optimizer,
                 conversationally=conversationally,
                 voice=voice,
                 voice_name=voice_name,
                 output_file=output_file
             )
-             # get_message expects dict
-            return self.get_message(response_data)
+            if raw:
+                return response_data
+            else:
+                return self.get_message(response_data)
 
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response"""
@@ -411,19 +394,10 @@ if __name__ == '__main__':
     try: # Add try-except block for testing
         ai = PiAI(timeout=60)
         print("[bold blue]Testing Chat (Stream):[/bold blue]")
-        response = ai.chat(input(">>> "), stream=True)
+        response = ai.chat("hi", stream=True, raw=False)
         full_response = ""
         for chunk in response:
             print(chunk, end="", flush=True)
-            full_response += chunk
-        print("\n[bold green]Stream Test Complete.[/bold green]")
-
-        # Optional: Test non-stream
-        # print("\n[bold blue]Testing Chat (Non-Stream):[/bold blue]")
-        # response_non_stream = ai.chat("Hello again", stream=False)
-        # print(response_non_stream)
-        # print("[bold green]Non-Stream Test Complete.[/bold green]")
-
     except exceptions.FailedToGenerateResponseError as e:
         print(f"\n[bold red]API Error:[/bold red] {e}")
     except Exception as e:

webscout/Provider/StandardInput.py

@@ -1,7 +1,7 @@
 from curl_cffi.requests import Session 
 import uuid
 import re
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Generator, Optional, Union
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
@@ -166,7 +166,8 @@ class StandardInputAI(Provider):
         prompt: str,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> Dict[str, Any]:
+        raw: bool = False,  # Added raw parameter
+    ) -> Union[Dict[str, Any], Generator[str, None, None]]:
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
@@ -233,9 +234,12 @@ class StandardInputAI(Provider):
             for content_chunk in processed_stream:
                 if content_chunk and isinstance(content_chunk, str):
                     full_response += content_chunk
-
+                    if raw:
+                        yield content_chunk
             self.last_response = {"text": full_response}
             self.conversation.update_chat_history(prompt, full_response)
+            if raw:
+                return full_response
             return {"text": full_response}
         except Exception as e:
             raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
@@ -245,17 +249,32 @@ class StandardInputAI(Provider):
         prompt: str,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> str:
-        return self.get_message(
-            self.ask(
-                prompt, optimizer=optimizer, conversationally=conversationally
+        raw: bool = False,  # Added raw parameter
+    ) -> Union[str, Generator[str, None, None]]:
+        def for_stream():
+            gen = self.ask(
+                prompt, optimizer=optimizer, conversationally=conversationally, raw=raw
             )
-        )
-
-    def get_message(self, response: dict) -> str:
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        # Extractor handles formatting
-        return response.get("text", "").replace('\\n', '\n').replace('\\n\\n', '\n\n')
+            if hasattr(gen, '__iter__') and not isinstance(gen, dict):
+                for chunk in gen:
+                    if raw:
+                        yield chunk
+                    else:
+                        yield self.get_message({"text": chunk})
+            else:
+                if raw:
+                    yield gen if isinstance(gen, str) else self.get_message(gen)
+                else:
+                    yield self.get_message(gen)
+        def for_non_stream():
+            result = self.ask(
+                prompt, optimizer=optimizer, conversationally=conversationally, raw=raw
+            )
+            if raw:
+                return result if isinstance(result, str) else self.get_message(result)
+            else:
+                return self.get_message(result)
+        return for_stream() if raw else for_non_stream()
 
 if __name__ == "__main__":
     print("-" * 100)

webscout/Provider/TTI/README.md

@@ -14,14 +14,14 @@ These providers allow you to easily generate AI‑created art from text prompts
 
 ## 📦 Supported Providers
 
-| Provider        | Available Models (examples)                        |
-|-----------------|----------------------------------------------------|
-| `AIArta`        | `flux`, `medieval`, `dreamshaper_xl`, ...          |
-| `FastFluxAI`    | `flux_1_schnell`                                   |
-| `MagicStudioAI` | `magicstudio`                                      |
-| `PixelMuse`     | `flux-schnell`, `imagen-3`, `recraft-v3`           |
-| `PiclumenAI`    | `piclumen-v1`                                      |
-| `PollinationsAI`| `flux`, `turbo`, `gptimage`                         |
+| Provider         | Available Models (examples)               |
+| ---------------- | ----------------------------------------- |
+| `AIArta`         | `flux`, `medieval`, `dreamshaper_xl`, ... |
+| `InfipAI`        | `img3`, `img4`, `uncen`                   |
+| `MagicStudioAI`  | `magicstudio`                             |
+| `PixelMuse`      | `flux-schnell`, `imagen-3`, `recraft-v3`  |
+| `PiclumenAI`     | `piclumen-v1`                             |
+| `PollinationsAI` | `flux`, `turbo`, `gptimage`               |
 
 > **Note**: Some providers require the `Pillow` package for image processing.
 
@@ -71,7 +71,7 @@ response = client.images.create(
 ## 🔧 Provider Specifics
 
 - **AIArta** – Uses Firebase authentication tokens and supports many tattoo‑style models.
-- **FastFluxAI** – Simple API for quick image generation.
+- **InfipAI** – Offers various models for different image styles.
 - **MagicStudioAI** – Generates images through MagicStudio's public endpoint.
 - **PixelMuse** – Supports several models and converts images from WebP.
 - **PiclumenAI** – Returns JPEG images directly from the API.

webscout/Provider/TTI/__init__.py

@@ -1,10 +1,11 @@
 from .pollinations import *
 from .piclumen import *
 from .magicstudio import *
-from .fastflux import *
 from .pixelmuse import *
 from .aiarta import *
 from .gpt1image import *
 from .imagen import *
 from .together import *
 from .bing import *
+from .infip import *
+from .monochat import *