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

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,9 +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 *

webscout/Provider/TTI/aiarta.py

@@ -24,6 +24,8 @@ import tempfile
 from webscout.litagent import LitAgent
 import time
 import json
+import random
+from pathlib import Path
 
 try:
     from PIL import Image
@@ -31,6 +33,10 @@ except ImportError:
     Image = None
 
 
+class ModelNotFoundError(Exception):
+    pass
+
+
 class Images(BaseImages):
     def __init__(self, client: "AIArta"):
         self._client = client
@@ -140,22 +146,23 @@ class Images(BaseImages):
             gen_headers = {
                 "Authorization": auth_data.get("idToken"),
             }
-            # Remove content-type header for form data
             if "content-type" in self._client.session.headers:
                 del self._client.session.headers["content-type"]
-            # get_model now returns the proper style name from model_aliases
-            style_value = self._client.get_model(model)
+            # Use the model name directly, not as 'style'
             image_payload = {
                 "prompt": str(prompt),
                 "negative_prompt": str(
                     kwargs.get("negative_prompt", "blurry, deformed hands, ugly")
                 ),
-                "style": str(style_value),
-                "images_num": str(1),  # Generate one image at a time in the loop
+                "style": str(model),  # Use 'style' key for the model name
+                "images_num": str(1),
                 "cfg_scale": str(kwargs.get("guidance_scale", 7)),
                 "steps": str(kwargs.get("num_inference_steps", 30)),
                 "aspect_ratio": str(aspect_ratio),
             }
+            # Remove 'model' from payload if present
+            if "model" in image_payload:
+                del image_payload["model"]
             # Step 2: Generate Image (send as form data, not JSON)
             image_response = self._client.session.post(
                 self._client.image_generation_url,
@@ -241,68 +248,67 @@ class Images(BaseImages):
 
 
 class AIArta(TTICompatibleProvider):
-    # Model aliases mapping from lowercase keys to proper API style names
-    model_aliases = {
-        "flux": "Flux",
-        "medieval": "Medieval",
-        "vincent_van_gogh": "Vincent Van Gogh",
-        "f_dev": "F Dev",
-        "low_poly": "Low Poly",
-        "dreamshaper_xl": "Dreamshaper-xl",
-        "anima_pencil_xl": "Anima-pencil-xl",
-        "biomech": "Biomech",
-        "trash_polka": "Trash Polka",
-        "no_style": "No Style",
-        "cheyenne_xl": "Cheyenne-xl",
-        "chicano": "Chicano",
-        "embroidery_tattoo": "Embroidery tattoo",
-        "red_and_black": "Red and Black",
-        "fantasy_art": "Fantasy Art",
-        "watercolor": "Watercolor",
-        "dotwork": "Dotwork",
-        "old_school_colored": "Old school colored",
-        "realistic_tattoo": "Realistic tattoo",
-        "japanese_2": "Japanese_2",
-        "realistic_stock_xl": "Realistic-stock-xl",
-        "f_pro": "F Pro",
-        "revanimated": "RevAnimated",
-        "katayama_mix_xl": "Katayama-mix-xl",
-        "sdxl_l": "SDXL L",
-        "cor_epica_xl": "Cor-epica-xl",
-        "anime_tattoo": "Anime tattoo",
-        "new_school": "New School",
-        "death_metal": "Death metal",
-        "old_school": "Old School",
-        "juggernaut_xl": "Juggernaut-xl",
-        "photographic": "Photographic",
-        "sdxl_1_0": "SDXL 1.0",
-        "graffiti": "Graffiti",
-        "mini_tattoo": "Mini tattoo",
-        "surrealism": "Surrealism",
-        "neo_traditional": "Neo-traditional",
-        "on_limbs_black": "On limbs black",
-        "yamers_realistic_xl": "Yamers-realistic-xl",
-        "pony_xl": "Pony-xl",
-        "playground_xl": "Playground-xl",
-        "anything_xl": "Anything-xl",
-        "flame_design": "Flame design",
-        "kawaii": "Kawaii",
-        "cinematic_art": "Cinematic Art",
-        "professional": "Professional",
-        "black_ink": "Black Ink",
-    }
-
-    AVAILABLE_MODELS = list(model_aliases.keys())
-    default_model = "Flux"
-    default_image_model = default_model
+    url = "https://ai-arta.com"
+    auth_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
+    token_refresh_url = "https://securetoken.googleapis.com/v1/token?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
+    image_generation_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image"
+    status_check_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image/{record_id}/status"
+    AVAILABLE_MODELS = [
+        "Anything-xl",
+        "High GPT4o",
+        "On limbs black",
+        "F Dev",
+        "SDXL 1.0",
+        "Old School",
+        "Vincent Van Gogh",
+        "Cor-epica-xl",
+        "Professional",
+        "Cheyenne-xl",
+        "Chicano",
+        "SDXL L",
+        "Black Ink",
+        "Juggernaut-xl",
+        "Cinematic Art",
+        "Dreamshaper-xl",
+        "Fantasy Art",
+        "Neo-traditional",
+        "Realistic-stock-xl",
+        "Flame design",
+        "Japanese_2",
+        "Medieval",
+        "Surrealism",
+        "Dotwork",
+        "Graffiti",
+        "RevAnimated",
+        "On limbs color",
+        "Old school colored",
+        "GPT4o Ghibli",
+        "Low Poly",
+        "GPT4o",
+        "No Style",
+        "Anime",
+        "tattoo",
+        "Embroidery tattoo",
+        "Mini tattoo",
+        "Realistic tattoo",
+        "Playground-xl",
+        "Watercolor",
+        "F Pro",
+        "Kawaii",
+        "Photographic",
+        "Katayama-mix-xl",
+        "Death metal",
+        "New School",
+        "Pony-xl",
+        "Anima-pencil-xl",
+        "Flux",
+        "Biomech",
+        "Yamers-realistic-xl",
+        "Trash Polka",
+        "Red and Black",
+    ]
 
     def __init__(self):
-        self.image_generation_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image"
-        self.status_check_url = (
-            "https://img-gen-prod.ai-arta.com/api/v1/text2image/{record_id}/status"
-        )
-        self.auth_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
-        self.token_refresh_url = "https://securetoken.googleapis.com/v1/token?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
         self.session = requests.Session()
         self.user_agent = LitAgent().random()
         self.headers = {
@@ -316,11 +322,11 @@ class AIArta(TTICompatibleProvider):
         self.images = Images(self)
 
     def get_auth_file(self) -> str:
-        path = os.path.join(os.path.expanduser("~"), ".ai_arta_cookies")
-        if not os.path.exists(path):
-            os.makedirs(path)
+        import tempfile
+        # Use a temp file in the system's temp directory, unique per class
         filename = f"auth_{self.__class__.__name__}.json"
-        return os.path.join(path, filename)
+        temp_dir = tempfile.gettempdir()
+        return os.path.join(temp_dir, filename)
 
     def create_token(self, path: str) -> Dict[str, Any]:
         auth_payload = {"clientType": "CLIENT_TYPE_ANDROID"}
@@ -369,17 +375,25 @@ class AIArta(TTICompatibleProvider):
                 return auth_data
         return self.create_token(path)
 
-    def get_model(self, model_name: str) -> str:
-        # Convert to lowercase for lookup
-        model_key = model_name.lower()
-        # Return the proper style name from model_aliases, or the original if not found
-        return self.model_aliases.get(model_key, model_name)
+    def get_model(self, model: str) -> str:
+        if not model:
+            return self.default_model
+        if model in self.models:
+            return model
+        raise ModelNotFoundError(f"Model {model} not found")
 
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+    @property
+    def models_list(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).models
 
         return _ModelList()
 
@@ -390,10 +404,10 @@ if __name__ == "__main__":
 
     client = AIArta()
     response = client.images.create(
-        model="flux",
-        prompt="a white siamese cat",
+        model="GPT4o",
+        prompt="Chitt Robot saying 'Hello World'",
         response_format="url",
-        n=2,
-        timeout=30,
+        n=1,
+        timeout=3000,
     )
     print(response)