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

webscout/Provider/Deepseek.py

@@ -64,23 +64,24 @@ class DeepSeek(Provider):
         self.timeout = timeout
         self.last_response = {}
         self.headers = {
-            "authority": "chat.deepseek.com",
             "accept": "*/*",
             "accept-encoding": "gzip, deflate, br, zstd",
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
             "authorization": f"Bearer {self.api_token}",
+            "content-length": "128",
             "content-type": "application/json",
             "dnt": "1",
             "origin": "https://chat.deepseek.com",
-            "referer": "https://chat.deepseek.com",
-            "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "priority": "u=1, i",
+            "referer": "https://chat.deepseek.com/",
+            "sec-ch-ua": '"Chromium";v="130", "Microsoft Edge";v="130", "Not?A_Brand";v="99"',
             "sec-ch-ua-mobile": "?0",
             "sec-ch-ua-platform": '"Windows"',
             "sec-fetch-dest": "empty",
             "sec-fetch-mode": "cors",
             "sec-fetch-site": "same-origin",
-            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0",
-            "x-app-version": "20240126.0"
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0",
+            "x-app-version": "20241018.0"
         }
         self.__available_optimizers = (
             method
@@ -223,4 +224,4 @@ if __name__ == '__main__':
     ai = DeepSeek(api_key="", timeout=5000)
     response = ai.chat("write a poem about AI", stream=True)
     for chunk in response:
-        print(chunk, end="", flush=True)
+        print(chunk, end="", flush=True)

webscout/Provider/EDITEE.py

@@ -1,4 +1,4 @@
-import requests
+import cloudscraper
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation, Proxy
 from webscout.AIutel import AwesomePrompts, sanitize_stream
@@ -49,7 +49,7 @@ class Editee(Provider):
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
 
-        self.session = requests.Session()
+        self.session = cloudscraper.create_scraper()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://editee.com/submit/chatgptfree"

webscout/Provider/GPTWeb.py

@@ -188,6 +188,6 @@ class GPTWeb(Provider):
 if __name__ == '__main__':
     from rich import print
     ai = GPTWeb()
-    response = ai.chat(input(">>> "))
+    response = ai.chat("tell me about Abhay koul, HelpingAI", stream=True)
     for chunk in response:
         print(chunk, end='', flush=True)

webscout/Provider/Llama3.py

@@ -183,7 +183,7 @@ class LLAMA3(Provider):
 
 if __name__ == "__main__":
     from rich import print
-    ai = LLAMA3(api_key='7979b01c-c5ea-40df-9198-f45733fa2208')
+    ai = LLAMA3(api_key='')
     response = ai.chat(input(">>> "))
     for chunks in response:
         print(chunks, end="", flush=True)

webscout/Provider/NinjaChat.py

@@ -0,0 +1,200 @@
+import requests
+import json
+import os
+from typing import Any, Dict, Optional, Generator, List, Union
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider, AsyncProvider
+from webscout import exceptions
+
+
+class NinjaChat(Provider):
+    """
+    A class to interact with the NinjaChat API.
+    """
+
+    AVAILABLE_MODELS = {
+        "mistral": "https://www.ninjachat.ai/api/mistral",
+        "perplexity": "https://www.ninjachat.ai/api/perplexity",
+        "claude-3.5": "https://www.ninjachat.ai/api/claude-pro",
+        "gemini-1.5-pro": "https://www.ninjachat.ai/api/gemini",
+        "llama": "https://www.ninjachat.ai/api/llama-pro",
+        "o1-mini": "https://www.ninjachat.ai/api/o1-mini",
+    }
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,  # System message/intro prompt
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "perplexity",  # Default model
+        system_message: str = "You are a helpful AI assistant.",  # Default system message
+    ):
+        """Initializes the NinjaChat API client."""
+
+        self.headers = {
+                "Accept": "*/*",
+                "Accept-Encoding": "gzip, deflate, br, zstd",
+                "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+                "Content-Type": "application/json",
+                "Cookie": "_ga=GA1.1.298084589.1727859540; _ga_11N4NZX9WP=GS1.1.1727859539.1.0.1727859552.0.0.0; __stripe_mid=4f63db68-c41d-45b4-9111-2457a6cf1b538696a9; __Host-next-auth.csrf-token=a5cb5a40c73df3e808ebc072dcb116fe7dd4b9b8d39d8002ef7e54153e6aa665%7Cbffe3f934f2db43330d281453af2cd0b4757f439b958f2d1a06a36cea63e9cc8; __stripe_sid=118678d1-403a-43f9-b3b9-d80ed9392a0d2ac131; __Secure-next-auth.callback-url=https%3A%2F%2Fwww.ninjachat.ai%2Fdashboard; __Secure-next-auth.session-token=eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0..l34CIFGTJCtstUqU.VjEYgaUUPpgp-49wueXFlFYvbm8csuyX0HichHrPNH45nX4s_LeZX2VhK1ZvwmUpfdlsMD4bi8VzFfQUEgs8FLPhkbKnoZDP939vobV7K_2Q9CA8PgC0oXEsQf_azWmILZ8rOE37uYzTu1evCnOjCucDYrC1ONXzl9NbGNPVa8AQr7hXvatuqtqe-lBUQXWdrw3QLulbqxvh6yLoxJj04gqC-nPudGciU-_-3TZJYr98u8o7KtUGio1ZX9vHNFfv8djWM1NCkji3Kl9eUhiyMj71.6uhUS39UcCVRa6tFzHxz2g; ph_phc_wWUtqcGWqyyochfPvwKlXMkMjIoIQKUwcnHE3KMKm8K_posthog=%7B%22distinct_id%22%3A%2201924c74-2926-7042-a1fb-5b5debdbcd1c%22%2C%22%24sesid%22%3A%5B1727966419499%2C%22019252bb-9de4-75db-9f85-a389fb401670%22%2C1727964880355%5D%7D",
+                "DNT": "1",
+                "Origin": "https://www.ninjachat.ai",
+                "Priority": "u=1, i",
+                "Referer": "https://www.ninjachat.ai/dashboard",
+                "Sec-CH-UA": '"Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
+                "Sec-CH-UA-Mobile": "?0",
+                "Sec-CH-UA-Platform": '"Windows"',
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-origin",
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"
+                )
+    }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.last_response = {}
+        self.system_message = system_message
+
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        
+        #Set the intro/system message
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or system_message or Conversation.intro #Priority: act > intro > system_message > Conversation.intro
+
+        )
+
+
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {', '.join(self.AVAILABLE_MODELS)}")
+        self.model_url = self.AVAILABLE_MODELS[model]
+        self.headers["Referer"] = self.model_url  # Set initial referer
+
+
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict, Generator]:
+
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt, intro=Conversation.intro)
+
+        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}")
+
+        #Include the system message in the payload
+        payload = {
+            "messages": [
+                {"role": "system", "content": self.system_message}, # System message here
+                {"role": "user", "content": conversation_prompt},
+            ],
+            "stream": stream  # Now passed dynamically
+        }
+
+        def for_stream():
+            try:
+                with requests.post(self.model_url, headers=self.headers, json=payload, stream=True, timeout=self.timeout) as response:
+                    response.raise_for_status()
+                    streaming_text = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line:
+                            if line.startswith("0:"):
+                                try:
+                                    text = json.loads(line[2:]) # Extract streaming text
+                                    streaming_text += text #Accumulate for history
+                                    resp = dict(text=text)
+                                    yield resp if raw else resp
+                                except json.JSONDecodeError:
+                                    print("\n[Error] Failed to decode JSON content.")
+
+                            elif line.startswith("d:"):
+                                break #End of stream
+                    self.conversation.update_chat_history(prompt, streaming_text)
+                    self.last_response.update({"text": streaming_text})
+            except requests.exceptions.RequestException as e:
+                print("An error occurred:", e)
+
+
+
+        def for_non_stream():
+
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator]:
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt, False, optimizer=optimizer, conversationally=conversationally
+                )
+            )
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+
+
+if __name__ == "__main__":
+    from rich import print
+    bot = NinjaChat(model="perplexity", system_message="You are a creative writer.")
+
+    response = bot.chat("tell me about Abhay koul, HelpingAI ", stream=True)
+
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout/Provider/OLLAMA.py

@@ -166,7 +166,7 @@ class OLLAMA(Provider):
         assert isinstance(response, dict), "Response should be of dict data-type only"
         return response["text"]
 if __name__ == "__main__":
-    ai = OLLAMA(model="qwen2:0.5b")
+    ai = OLLAMA(model="llama3.2:1b")
     response = ai.chat("write a poem about AI", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)

webscout/Provider/Perplexity.py

@@ -592,7 +592,7 @@ class Perplexity(Provider):
 if __name__ == "__main__":
     perplexity = Perplexity() 
     # Stream the response
-    response = perplexity.chat("What is the meaning of life?")
+    response = perplexity.chat("tell me about Abhay koul, HelpingAI ")
     for chunk in response:
         print(chunk, end="", flush=True)
 

webscout/Provider/Reka.py

@@ -4,10 +4,10 @@ import requests
 
 import json
 
-from ..AIutel import Optimizers
-from ..AIutel import Conversation
-from ..AIutel import AwesomePrompts, sanitize_stream
-from ..AIbase import  Provider, AsyncProvider
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import  Provider, AsyncProvider
 from webscout import exceptions
 
 #-----------------------------------------------REKA-----------------------------------------------
@@ -205,4 +205,11 @@ class REKA(Provider):
             str: Message extracted
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response.get("text")
+        return response.get("text")
+if __name__ == "__main__":
+    
+    from rich import print
+    ai = REKA(api_key="YOUR_API_KEY", timeout=5000)
+    response = ai.chat("write a poem about AI", stream=True)
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout/Provider/TTI/AIuncensored.py

@@ -0,0 +1,103 @@
+import requests
+import json
+import os
+from datetime import datetime
+from typing import List, Dict, Optional
+
+from webscout.AIbase import ImageProvider
+from webscout import exceptions
+
+
+class AIUncensoredImager(ImageProvider):
+    """
+    Image provider for AIUncensored.info.
+    """
+
+    def __init__(self, timeout: int = 60, proxies: dict = {}):
+        """Initializes the AIUncensoredImager class."""
+        self.url = "https://twitterclone-i0wr.onrender.com/api/image"
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "*/*",
+            "Origin": "https://www.aiuncensored.info",
+            "Referer": "https://www.aiuncensored.info/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0",
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.prompt = "AI-generated image - webscout"
+        self.image_extension = "jpg"
+
+    def generate(self, prompt: str, amount: int = 1) -> List[str]:
+        """Generates image URLs from a prompt."""
+
+        assert bool(prompt), "Prompt cannot be null"
+        assert isinstance(amount, int) and amount > 0, "Amount must be a positive integer"
+        self.prompt = prompt
+
+        payload = {"prompt": prompt}
+        image_urls = []
+
+        try:
+            with self.session.post(self.url, json=payload, timeout=self.timeout) as response:
+                response.raise_for_status()  # Raise HTTPError for bad responses
+                data = response.json()
+                image_url = data.get("image_url")
+
+                if not image_url:
+                    raise exceptions.InvalidResponseError("No image URL in API response")
+
+                image_urls.append(image_url) # Only one image returned for now
+
+
+        except requests.exceptions.RequestException as e:
+            raise exceptions.APIConnectionError(f"Error during request: {e}")
+        except json.JSONDecodeError as e:
+            raise exceptions.InvalidResponseError(f"Invalid JSON response: {e}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Unexpected error: {e}")
+
+        return image_urls
+
+    def save(
+        self,
+        response: List[str],
+        name: str = None,
+        dir: str = os.getcwd(),
+        filenames_prefix: str = "",
+    ) -> List[str]:
+        """Saves generated images."""
+
+        assert isinstance(response, list), f"Response should be a list, not {type(response)}"
+        name = self.prompt if name is None else name
+        os.makedirs(dir, exist_ok=True) #Create dir if needed
+
+        filenames = []
+        for i, img_url in enumerate(response):
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"{dir}/{name}_{i + 1}_{timestamp}.{self.image_extension}"
+            filenames.append(filenames_prefix + os.path.basename(filename))
+
+            try:
+                with self.session.get(img_url, stream=True, timeout=self.timeout) as img_response:
+                    img_response.raise_for_status()
+                    with open(filename, "wb") as f:
+                        for chunk in img_response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+            except requests.exceptions.RequestException as e:
+                raise exceptions.FailedToSaveImageError(f"Error downloading/saving image: {e}")
+
+        return filenames
+
+
+if __name__ == "__main__":
+    imager = AIUncensoredImager()
+    prompt = "a photo of a cat sitting in a basket"
+    try:
+        image_urls = imager.generate(prompt, amount=1)
+        saved_filenames = imager.save(image_urls)
+        print(f"Saved filenames: {saved_filenames}")
+    except Exception as e:
+        print(f"An error occurred: {e}")

webscout/Provider/TTI/Nexra.py

@@ -11,7 +11,7 @@ class NexraImager(ImageProvider):
     """Image provider for Nexra API"""
 
     AVAILABLE_MODELS = {
-        "standard": ["emi", "stablediffusion-1.5", "stablediffusion-2.1", "sdxl-lora", "dalle", "dalle2", "dalle-mini"],
+        "standard": ["emi", "stablediffusion-1.5", "stablediffusion-2.1", "sdxl-lora", "dalle", "dalle2", "dalle-mini", "flux", "midjourney"],
         "prodia": [
             "dreamshaperXL10_alpha2.safetensors [c8afe2ef]",
             "dynavisionXL_0411.safetensors [c39cc051]",
@@ -37,7 +37,7 @@ class NexraImager(ImageProvider):
         self.image_extension: str = "png"
 
     def generate(
-        self, prompt: str, model: str = "emi", amount: int = 1,
+        self, prompt: str, model: str = "flux", amount: int = 1,
         max_retries: int = 3, retry_delay: int = 5,
         additional_params: Optional[dict] = None
     ) -> List[bytes]:
@@ -116,5 +116,5 @@ class NexraImager(ImageProvider):
 
 if __name__ == "__main__":
     bot = NexraImager()
-    resp_standard = bot.generate("AI-generated image - webscout", "emi", 1)
+    resp_standard = bot.generate("AI-generated image - webscout", "midjourney", 1)
     print(bot.save(resp_standard))

webscout/Provider/TTI/__init__.py

@@ -5,5 +5,7 @@ from .blackboximage import *
 from .Nexra import *
 from .huggingface import *
 from .artbit import *
-from .amigo import *
-from .WebSimAI import *
+from .WebSimAI import *
+from .imgninza import *
+from .AIuncensored import *
+from .talkai import *

webscout/Provider/TTI/aiforce.py

@@ -8,7 +8,7 @@ from requests.exceptions import RequestException
 
 from webscout.AIbase import ImageProvider
 
-class AiForceimagger(ImageProvider):
+class AiForceimager(ImageProvider):
     """Image provider for Airforce API"""
 
     AVAILABLE_MODELS = [
@@ -152,7 +152,7 @@ class AiForceimagger(ImageProvider):
         return filenames
 
 if __name__ == "__main__":
-    bot = AiForceimagger()
+    bot = AiForceimager()
     try:
         resp = bot.generate("A shiny red sports car speeding down a scenic mountain road", 1, model="flux-realism")
         print(bot.save(resp))

webscout/Provider/TTI/imgninza.py

@@ -0,0 +1,136 @@
+import requests
+import json
+import os
+from typing import List, Dict, Optional
+
+from webscout.AIbase import ImageProvider
+from webscout import exceptions  # Import exceptions module
+
+
+class NinjaImager(ImageProvider):
+    """
+    Image provider for NinjaChat.ai.
+    """
+
+    AVAILABLE_MODELS = {
+        "stable-diffusion": "https://www.ninjachat.ai/api/image-generator",
+        "flux-dev": "https://www.ninjachat.ai/api/flux-image-generator",
+    }
+
+    def __init__(self, timeout: int = 60, proxies: dict = {}):
+        """Initializes the NinjaChatImager class."""
+        self.headers = {
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "Content-Type": "application/json",
+            "DNT": "1",
+            "Origin": "https://www.ninjachat.ai",
+            "Priority": "u=1, i",
+            "Referer": "https://www.ninjachat.ai/image-generation",
+            "Sec-CH-UA": '"Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": '"Windows"',
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0",
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.prompt = "AI-generated image - webscout"
+        self.image_extension = "png"  # Default extension
+
+    def generate(self, prompt: str, amount: int = 1, model: str = "flux-dev") -> List[str]:
+        """Generate images from a prompt."""
+
+        assert bool(prompt), "Prompt cannot be null"
+        assert isinstance(amount, int) and amount > 0, "Amount should be a positive integer"
+
+        if model not in self.AVAILABLE_MODELS:
+            raise exceptions.ModelNotFoundError(f"Model '{model}' not found. Available models: {', '.join(self.AVAILABLE_MODELS)}")
+
+        self.prompt = prompt  # Store the prompt
+        url = self.AVAILABLE_MODELS[model]
+
+        payload = {
+            "prompt": prompt,
+            "model": model if model == "flux-dev" else "stable-diffusion", # Pass model name to API if needed
+            "negativePrompt": "", #Use negative prompt from API's data structure
+            "cfg": 7,
+            "aspectRatio": "1:1",
+            "outputFormat": self.image_extension,
+            "numOutputs": amount,
+            "outputQuality": 90
+        }
+
+
+        image_urls = []
+        try:
+            with requests.post(url, headers=self.headers, json=payload, timeout=self.timeout) as response:
+                if response.status_code != 200:
+                    raise exceptions.FailedToGenerateResponseError(f"Request failed with status code: {response.status_code}, {response.text}")  # Raise Webscout exception
+
+                data = response.json()
+
+                if 'output' not in data:
+                    raise exceptions.InvalidResponseError("Invalid API response format: 'output' key missing.")
+
+                for img_url in data['output']:
+                    image_urls.append(img_url)
+
+        except requests.exceptions.RequestException as e:
+            raise exceptions.APIConnectionError(f"An error occurred during the request: {e}") # More specific exception
+        except json.JSONDecodeError as e:
+            raise exceptions.InvalidResponseError(f"Failed to parse JSON response: {e}")
+
+        return image_urls
+
+
+    def save(
+        self,
+        response: List[str],
+        name: str = None,
+        dir: str = os.getcwd(),
+        filenames_prefix: str = "",
+    ) -> List[str]:
+        """Saves generated images."""
+
+        assert isinstance(response, list), f"Response should be a list, not {type(response)}"
+        name = self.prompt if name is None else name
+
+        filenames = []
+        count = 0
+        for img_url in response:
+            def complete_path():
+                count_value = "" if count == 0 else f"_{count}"
+                return os.path.join(dir, name + count_value + "." + self.image_extension)
+
+            while os.path.isfile(complete_path()):
+                count += 1
+
+            absolute_path_to_file = complete_path()
+            filenames.append(filenames_prefix + os.path.split(absolute_path_to_file)[1])
+            try:
+                with requests.get(img_url, stream=True, timeout=self.timeout) as img_response:
+                    img_response.raise_for_status()
+                    with open(absolute_path_to_file, "wb") as f:
+                        for chunk in img_response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.FailedToSaveImageError(f"An error occurred while downloading/saving image: {e}")
+
+        return filenames
+
+
+
+if __name__ == "__main__":
+    bot = NinjaImager()
+    try:
+        resp = bot.generate("A shiny red sports car speeding down a scenic mountain road", 1)
+        print(bot.save(resp))
+    except Exception as e:
+        print(f"An error occurred: {e}")