webscout 4.7__py3-none-any.whl → 4.8__py3-none-any.whl

webscout/Provider/{ChatGPTUK.py → Farfalle.py}

@@ -1,29 +1,28 @@
 import requests
-from typing import Any, AsyncGenerator, Dict, Optional
 import json
-import re
+from typing import Any, Dict, Optional
 
-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
+from webscout.AIbase import Provider, AsyncProvider
 from webscout import exceptions
 
 
-class ChatGPTUK(Provider):
+class Farfalle(Provider):
     """
-    A class to interact with the ChatGPT UK API.
+    A class to interact with the Farfalle.dev API.
     """
 
+    available_models = [
+        "gpt-3.5-turbo",
+
+    ]
+
     def __init__(
         self,
         is_conversation: bool = True,
         max_tokens: int = 600,
-        temperature: float = 0.9,
-        presence_penalty: float = 0,
-        frequency_penalty: float = 0,
-        top_p: float = 1,
-        model: str = "google-gemini-pro",
         timeout: int = 30,
         intro: str = None,
         filepath: str = None,
@@ -31,39 +30,54 @@ class ChatGPTUK(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
+        model: str = "gpt-3.5-turbo", 
     ) -> None:
         """
-        Initializes the ChatGPTUK API with given parameters.
+        Initializes the Farfalle.dev API with given parameters.
 
         Args:
             is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
-            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
-            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.9.
-            presence_penalty (float, optional): Chances of topic being repeated. Defaults to 0.
-            frequency_penalty (float, optional): Chances of word being repeated. Defaults to 0.
-            top_p (float, optional): Sampling threshold during inference time. Defaults to 1.
-            model (str, optional): LLM model name. Defaults to "google-gemini-pro".
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. 
+                                        Defaults to 600.
             timeout (int, optional): Http request timeout. Defaults to 30.
             intro (str, optional): Conversation introductory prompt. Defaults to None.
             filepath (str, optional): Path to file containing conversation history. Defaults to None.
             update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
             proxies (dict, optional): Http request proxies. Defaults to {}.
-            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            history_offset (int, optional): Limit conversation history to this number of last texts. 
+                                            Defaults to 10250.
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): AI model to use. Defaults to "gpt-3.5-turbo". 
+                                    Options: "gpt-3.5-turbo", "gpt-4"
         """
+        if model not in self.available_models:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.available_models}")
+
         self.session = requests.Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
-        self.api_endpoint = "https://free.chatgpt.org.uk/api/openai/v1/chat/completions"
+        self.api_endpoint = "https://api.farfalle.dev/chat"
         self.stream_chunk_size = 64
         self.timeout = timeout
         self.last_response = {}
         self.model = model
-        self.temperature = temperature
-        self.presence_penalty = presence_penalty
-        self.frequency_penalty = frequency_penalty
-        self.top_p = top_p
-        self.headers = {"Content-Type": "application/json"}
+        self.headers = {
+            "accept": "text/event-stream",
+            "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.farfalle.dev",
+            "priority": "u=1, i",
+            "referer": "https://www.farfalle.dev/",
+            "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "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"
+        }
 
         self.__available_optimizers = (
             method
@@ -91,22 +105,19 @@ class ChatGPTUK(Provider):
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> dict:
-        """Chat with AI
+    ) -> Dict[str, Any]:
+        """
+        Sends a prompt to the Farfalle.dev API and returns the response.
 
         Args:
-            prompt (str): Prompt to be send.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            prompt: The text prompt to generate text from.
+            stream (bool, optional): Whether to stream the response. Defaults to False.
+            raw (bool, optional): Whether to return the raw response. Defaults to False.
+            optimizer (str, optional): The name of the optimizer to use. Defaults to None.
+            conversationally (bool, optional): Whether to chat conversationally. Defaults to False.
+
         Returns:
-           dict : {}
-        ```json
-        {
-           "text" : "How may I assist you today?"
-        }
-        ```
+            The response from the API.
         """
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -118,47 +129,41 @@ class ChatGPTUK(Provider):
                 raise Exception(
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
-
-        self.session.headers.update(self.headers)
+        
         payload = {
-            "messages": [
-                {"role": "system", "content": "Keep your responses long and detailed"},
-                {"role": "user", "content": conversation_prompt}
-            ],
-            "stream": True,
-            "model": self.model,
-            "temperature": self.temperature,
-            "presence_penalty": self.presence_penalty,
-            "frequency_penalty": self.frequency_penalty,
-            "top_p": self.top_p,
-            "max_tokens": self.max_tokens_to_sample
+            "query": conversation_prompt,
+            "model": self.model 
         }
 
         def for_stream():
             response = self.session.post(
-                self.api_endpoint, json=payload, stream=True, timeout=self.timeout
+                self.api_endpoint, json=payload, headers=self.headers, stream=True, timeout=self.timeout
             )
+
             if not response.ok:
                 raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    f"Failed to generate response - ({response.status_code}, {response.reason})"
                 )
-
+            
             streaming_response = ""
-            for line in response.iter_lines(decode_unicode=True, chunk_size=1):
+            for line in response.iter_lines():
                 if line:
-                    modified_line = re.sub("data:", "", line)
-                    try:
-                        json_data = json.loads(modified_line)
-                        content = json_data['choices'][0]['delta']['content']
-                        streaming_response += content
-                        yield content if raw else dict(text=streaming_response)
-                    except:
-                        continue
+                    decoded_line = line.decode('utf-8')
+                    if decoded_line.startswith("data:"):
+                        data = decoded_line[len("data:"):].strip()
+                        if data:
+                            try:
+                                event = json.loads(data)
+                                if event.get("event") == "final-response":
+                                    message = event['data'].get('message', '')
+                                    streaming_response += message
+                                    yield message if raw else dict(text=streaming_response)
+                            except json.decoder.JSONDecodeError:
+                                continue
             self.last_response.update(dict(text=streaming_response))
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
-
         def for_non_stream():
             for _ in for_stream():
                 pass
@@ -211,4 +216,12 @@ class ChatGPTUK(Provider):
             str: Message extracted
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        return response["text"]
+if __name__ == "__main__":
+    from rich import print
+
+    ai = Farfalle() 
+    # Stream the response
+    response = ai.chat(input(">>> "))
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout/Provider/Gemini.py

@@ -28,7 +28,7 @@ from webscout import exceptions
 from typing import Any, AsyncGenerator, Dict
 import logging
 import httpx    
-from Bard import Chatbot
+from ..Bard import Chatbot
 import logging
 from os import path
 from json import load