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

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="gemini-1.5-pro", system_message="You are a creative writer.")
+
+    response = bot.chat("write a poem about a robot learning to love", stream=True)
+
+    for chunk in response:
+        print(chunk, end="", flush=True)

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

@@ -6,4 +6,5 @@ from .Nexra import *
 from .huggingface import *
 from .artbit import *
 from .amigo import *
-from .WebSimAI import *
+from .WebSimAI import *
+from .imgninza 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}")

webscout/Provider/Youchat.py

@@ -224,6 +224,6 @@ class YouChat(Provider):
 if __name__ == '__main__':
     from rich import print
     ai = YouChat(timeout=5000)
-    response = ai.chat("write a poem about AI", stream=True)
+    response = ai.chat("Who is Abhay Koul in AI?", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)

webscout/Provider/__init__.py

@@ -62,6 +62,10 @@ from .Amigo import *
 from .prefind import *
 from .bagoodex import *
 from .ChatHub import *
+from .aimathgpt import *
+from .gaurish import *
+from .geminiprorealtime import *
+from .NinjaChat import *
 __all__ = [
     'Farfalle',
     'LLAMA', 
@@ -126,7 +130,10 @@ __all__ = [
     'PrefindAI',
     'Bagoodex',
     'ChatHub',
-    # 'LearnFast',
+    'AIMathGPT',
+    'GaurishCerebras',
+    'GeminiPro',
+    'NinjaChat',
 
 
 ]

webscout/Provider/aimathgpt.py

@@ -0,0 +1,193 @@
+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 AIMathGPT(Provider):
+    """
+    A class to interact with the AIMathGPT API.
+    """
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "llama3",  # Default model
+        system_prompt: str = "You are a helpful AI assistant.",
+    ):
+        """
+        Initializes the AIMathGPT API with the given parameters.
+        """
+        self.url = "https://aimathgpt.forit.ai/api/ai"
+        self.headers = {
+            "authority": "aimathgpt.forit.ai",
+            "method": "POST",
+            "path": "/api/ai",
+            "scheme": "https",
+            "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": (
+                "NEXT_LOCALE=en; _ga=GA1.1.1515823701.1726936796; "
+                "_ga_1F3ZVN96B1=GS1.1.1726936795.1.1.1726936833.0.0.0"
+            ),
+            "dnt": "1",
+            "origin": "https://aimathgpt.forit.ai",
+            "priority": "u=1, i",
+            "referer": "https://aimathgpt.forit.ai/?ref=taaft&utm_source=taaft&utm_medium=referral",
+            "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.model = model
+        self.system_prompt = system_prompt
+        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("__")
+        )
+        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
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict, Generator]:
+        """Sends a chat completion request to the AIMathGPT API."""
+        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}")
+
+
+        payload = {
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": conversation_prompt},
+            ],
+            "model": self.model,
+        }
+
+
+        def for_stream():
+            try:
+                with requests.post(self.url, headers=self.headers, data=json.dumps(payload), stream=True, timeout=self.timeout) as response:
+                    if response.status_code != 200:
+                        raise exceptions.FailedToGenerateResponseError(f"Request failed with status code {response.status_code}: {response.text}")
+
+                    streaming_text = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line:
+                            try:
+                                data = json.loads(line)
+                                if 'result' in data and 'response' in data['result']:
+                                    content = data['result']['response']
+                                    streaming_text += content
+                                    resp = dict(text=content)  # Yield only the new content
+                                    yield resp if raw else resp
+                                else:
+                                    pass
+                            except json.JSONDecodeError:
+                                pass
+                    self.conversation.update_chat_history(prompt, streaming_text)
+                    self.last_response.update({"text": streaming_text})
+            except requests.exceptions.RequestException as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {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, stream=True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt, stream=False, optimizer=optimizer, conversationally=conversationally
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response"""
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+
+if __name__ == "__main__":
+    from rich import print
+    bot = AIMathGPT()
+    try:
+        response = bot.chat("What is the capital of France?", stream=True)
+        for chunk in response:
+            print(chunk, end="", flush=True)
+    except Exception as e:
+        print(f"An error occurred: {e}")

webscout/Provider/felo_search.py

@@ -175,6 +175,6 @@ class Felo(Provider):
 if __name__ == '__main__':
     from rich import print
     ai = Felo()
-    response = ai.chat("hi")
+    response = ai.chat("tell me about HelpingAI-9B", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)