webscout 5.2__tar.gz → 5.3__tar.gz

{webscout-5.2/webscout.egg-info → webscout-5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 5.2
+Version: 5.3
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author: OEvortex
 Author-email: helpingai5@gmail.com
@@ -339,57 +339,12 @@ if __name__ == '__main__':
 ## Transcriber
 The transcriber function in webscout is a handy tool that transcribes YouTube videos. Here's an example code demonstrating its usage:
 ```python
-import sys
-from webscout import transcriber
-
-def extract_transcript(video_id):
-    """Extracts the transcript from a YouTube video."""
-    try:
-        transcript_list = transcriber.list_transcripts(video_id)
-        for transcript in transcript_list:
-            transcript_data_list = transcript.fetch()
-            lang = transcript.language
-            transcript_text = ""
-            if transcript.language_code == 'en':
-                for line in transcript_data_list:
-                    start_time = line['start']
-                    end_time = start_time + line['duration']
-                    formatted_line = f"{start_time:.2f} - {end_time:.2f}: {line['text']}\n"
-                    transcript_text += formatted_line
-                return transcript_text
-            elif transcript.is_translatable:
-                english_transcript_list = transcript.translate('en').fetch()
-                for line in english_transcript_list:
-                    start_time = line['start']
-                    end_time = start_time + line['duration']
-                    formatted_line = f"{start_time:.2f} - {end_time:.2f}: {line['text']}\n"
-                    transcript_text += formatted_line
-                return transcript_text
-        print("Transcript extraction failed. Please check the video URL.")
-    except Exception as e:
-        print(f"Error: {e}")
-
-def main():
-    video_url = input("Enter the video link: ")
-
-    if video_url:
-        video_id = video_url.split("=")[1]
-        print("Video URL:", video_url)
-        submit = input("Press 'Enter' to get the transcript or type 'exit' to quit: ")
-        if submit == '':
-            print("Extracting Transcript...")
-            transcript = extract_transcript(video_id)
-            print('Transcript:')
-            print(transcript)
-            print("__________________________________________________________________________________")
-        elif submit.lower() == 'exit':
-            print("Exiting...")
-            sys.exit()
-        else:
-            print("Invalid input. Please try again.")
-
-if __name__ == "__main__":
-    main()
+from webscout import YTTranscriber
+yt = YTTranscriber()
+from rich import print
+video_url = input("Enter the YouTube video URL: ") 
+transcript = yt.get_transcript(video_url, languages=None) 
+print(transcript)
 ```
 
 ## GoogleS -- formerly DWEBS
@@ -397,7 +352,7 @@ if __name__ == "__main__":
 from webscout import GoogleS
 from rich import print
 searcher = GoogleS()
-results = searcher.search("HelpingAI-9B", max_results=20, extract_webpage_text=False, max_extract_characters=100)
+results = searcher.search("HelpingAI-9B", max_results=20, extract_text=False, max_text_length=200)
 for result in results:
     print(result)
 ```
@@ -411,36 +366,20 @@ for result in results:
     print(result)
 ```
 
-## Text-to-Speech:
-```python
-from webscout import play_audio
-
-message = "This is an example of text-to-speech."
-audio_content = play_audio(message, voice="Brian")
-
-# Save the audio to a file
-with open("output.mp3", "wb") as f:
-    f.write(audio_content)
-```
-### Available TTS Voices:
-You can choose from a wide range of voices, including:
-- Filiz, Astrid, Tatyana, Maxim, Carmen, Ines, Cristiano, Vitoria, Ricardo, Maja, Jan, Jacek, Ewa, Ruben, Lotte, Liv, Seoyeon, Takumi, Mizuki, Giorgio, Carla, Bianca, Karl, Dora, Mathieu, Celine, Chantal, Penelope, Miguel, Mia, Enrique, Conchita, Geraint, Salli, Matthew, Kimberly, Kendra, Justin, Joey, Joanna, Ivy, Raveena, Aditi, Emma, Brian, Amy, Russell, Nicole, Vicki, Marlene, Hans, Naja, Mads, Gwyneth, Zhiyu
-- Standard and WaveNet voices for various languages (e.g., en-US, es-ES, ja-JP, etc.)
-
 
 The WEBS and AsyncWEBS classes are used to retrieve search results from DuckDuckGo.com 
 To use the AsyncWEBS class, you can perform asynchronous operations using Python's asyncio library.
 To initialize an instance of the WEBS or AsyncWEBS classes, you can provide the following optional arguments:
 
 Here is an example of initializing the WEBS class:
-```python3
+```python
 from webscout import WEBS
 
 R = WEBS().text("python programming", max_results=5)
 print(R)
 ```
 Here is an example of initializing the AsyncWEBS class:
-```python3
+```python
 import asyncio
 import logging
 import sys
@@ -913,7 +852,7 @@ resp = bot.generate("AI-generated image - webscout", 1)
 print(bot.save(resp))
 ```
 
-### Text to Speach - Voicepods, StreamElements
+### Text to speech  - Voicepods, StreamElements
 ```python
 from webscout import Voicepods
 voicepods = Voicepods()
@@ -1492,7 +1431,7 @@ if "error" not in function_call_data:
 else:
     print(f"Error: {function_call_data['error']}")
 ```
-###  LLAMA3, pizzagpt, RUBIKSAI, Koala, Darkai, AI4Chat, Farfalle, PIAI, Felo, XDASH, Julius, YouChat, YEPCHAT, Cloudflare, TurboSeek, NetFly, Editee
+###  LLAMA3, pizzagpt, RUBIKSAI, Koala, Darkai, AI4Chat, Farfalle, PIAI, Felo, XDASH, Julius, YouChat, YEPCHAT, Cloudflare, TurboSeek, NetFly, Editee, AI21, Chatify, Cerebras, X0GPT
 code similar to other provider
 ### `LLM` 
 ```python

{webscout-5.2 → webscout-5.3}/README.md

@@ -260,57 +260,12 @@ if __name__ == '__main__':
 ## Transcriber
 The transcriber function in webscout is a handy tool that transcribes YouTube videos. Here's an example code demonstrating its usage:
 ```python
-import sys
-from webscout import transcriber
-
-def extract_transcript(video_id):
-    """Extracts the transcript from a YouTube video."""
-    try:
-        transcript_list = transcriber.list_transcripts(video_id)
-        for transcript in transcript_list:
-            transcript_data_list = transcript.fetch()
-            lang = transcript.language
-            transcript_text = ""
-            if transcript.language_code == 'en':
-                for line in transcript_data_list:
-                    start_time = line['start']
-                    end_time = start_time + line['duration']
-                    formatted_line = f"{start_time:.2f} - {end_time:.2f}: {line['text']}\n"
-                    transcript_text += formatted_line
-                return transcript_text
-            elif transcript.is_translatable:
-                english_transcript_list = transcript.translate('en').fetch()
-                for line in english_transcript_list:
-                    start_time = line['start']
-                    end_time = start_time + line['duration']
-                    formatted_line = f"{start_time:.2f} - {end_time:.2f}: {line['text']}\n"
-                    transcript_text += formatted_line
-                return transcript_text
-        print("Transcript extraction failed. Please check the video URL.")
-    except Exception as e:
-        print(f"Error: {e}")
-
-def main():
-    video_url = input("Enter the video link: ")
-
-    if video_url:
-        video_id = video_url.split("=")[1]
-        print("Video URL:", video_url)
-        submit = input("Press 'Enter' to get the transcript or type 'exit' to quit: ")
-        if submit == '':
-            print("Extracting Transcript...")
-            transcript = extract_transcript(video_id)
-            print('Transcript:')
-            print(transcript)
-            print("__________________________________________________________________________________")
-        elif submit.lower() == 'exit':
-            print("Exiting...")
-            sys.exit()
-        else:
-            print("Invalid input. Please try again.")
-
-if __name__ == "__main__":
-    main()
+from webscout import YTTranscriber
+yt = YTTranscriber()
+from rich import print
+video_url = input("Enter the YouTube video URL: ") 
+transcript = yt.get_transcript(video_url, languages=None) 
+print(transcript)
 ```
 
 ## GoogleS -- formerly DWEBS
@@ -318,7 +273,7 @@ if __name__ == "__main__":
 from webscout import GoogleS
 from rich import print
 searcher = GoogleS()
-results = searcher.search("HelpingAI-9B", max_results=20, extract_webpage_text=False, max_extract_characters=100)
+results = searcher.search("HelpingAI-9B", max_results=20, extract_text=False, max_text_length=200)
 for result in results:
     print(result)
 ```
@@ -332,36 +287,20 @@ for result in results:
     print(result)
 ```
 
-## Text-to-Speech:
-```python
-from webscout import play_audio
-
-message = "This is an example of text-to-speech."
-audio_content = play_audio(message, voice="Brian")
-
-# Save the audio to a file
-with open("output.mp3", "wb") as f:
-    f.write(audio_content)
-```
-### Available TTS Voices:
-You can choose from a wide range of voices, including:
-- Filiz, Astrid, Tatyana, Maxim, Carmen, Ines, Cristiano, Vitoria, Ricardo, Maja, Jan, Jacek, Ewa, Ruben, Lotte, Liv, Seoyeon, Takumi, Mizuki, Giorgio, Carla, Bianca, Karl, Dora, Mathieu, Celine, Chantal, Penelope, Miguel, Mia, Enrique, Conchita, Geraint, Salli, Matthew, Kimberly, Kendra, Justin, Joey, Joanna, Ivy, Raveena, Aditi, Emma, Brian, Amy, Russell, Nicole, Vicki, Marlene, Hans, Naja, Mads, Gwyneth, Zhiyu
-- Standard and WaveNet voices for various languages (e.g., en-US, es-ES, ja-JP, etc.)
-
 
 The WEBS and AsyncWEBS classes are used to retrieve search results from DuckDuckGo.com 
 To use the AsyncWEBS class, you can perform asynchronous operations using Python's asyncio library.
 To initialize an instance of the WEBS or AsyncWEBS classes, you can provide the following optional arguments:
 
 Here is an example of initializing the WEBS class:
-```python3
+```python
 from webscout import WEBS
 
 R = WEBS().text("python programming", max_results=5)
 print(R)
 ```
 Here is an example of initializing the AsyncWEBS class:
-```python3
+```python
 import asyncio
 import logging
 import sys
@@ -834,7 +773,7 @@ resp = bot.generate("AI-generated image - webscout", 1)
 print(bot.save(resp))
 ```
 
-### Text to Speach - Voicepods, StreamElements
+### Text to speech  - Voicepods, StreamElements
 ```python
 from webscout import Voicepods
 voicepods = Voicepods()
@@ -1413,7 +1352,7 @@ if "error" not in function_call_data:
 else:
     print(f"Error: {function_call_data['error']}")
 ```
-###  LLAMA3, pizzagpt, RUBIKSAI, Koala, Darkai, AI4Chat, Farfalle, PIAI, Felo, XDASH, Julius, YouChat, YEPCHAT, Cloudflare, TurboSeek, NetFly, Editee
+###  LLAMA3, pizzagpt, RUBIKSAI, Koala, Darkai, AI4Chat, Farfalle, PIAI, Felo, XDASH, Julius, YouChat, YEPCHAT, Cloudflare, TurboSeek, NetFly, Editee, AI21, Chatify, Cerebras, X0GPT
 code similar to other provider
 ### `LLM` 
 ```python

{webscout-5.2 → webscout-5.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="5.2",
+    version="5.3",
     description="Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more",
     long_description=README,
     long_description_content_type="text/markdown",

{webscout-5.2 → webscout-5.3}/webscout/AIutel.py

@@ -594,16 +594,16 @@ w.print_weather(weather)
             interpreter (str, optional): Python's interpreter name. Defaults to Python.
             prettify (bool, optional): Prettify the code on stdout. Defaults to True.
         """
-        if not quiet:
-            print(
-                "Rawdog is an experimental tool that generates and auto-executes Python scripts in the cli.\n"
-                "To get the most out of Rawdog. Ensure the following are installed:\n"
-                " 1. Python 3.x\n"
-                " 2. Dependency:\n"
-                "  - Matplotlib\n"
-                "Be alerted on the risk posed! (Experimental)\n"
-                "Use '--quiet' to suppress this message and code/logs stdout.\n"
-            )
+        # if not quiet:
+        #     print(
+        #         "Rawdog is an experimental tool that generates and auto-executes Python scripts in the cli.\n"
+        #         "To get the most out of Rawdog. Ensure the following are installed:\n"
+        #         " 1. Python 3.x\n"
+        #         " 2. Dependency:\n"
+        #         "  - Matplotlib\n"
+        #         "Be alerted on the risk posed! (Experimental)\n"
+        #         "Use '--quiet' to suppress this message and code/logs stdout.\n"
+        #     )
         self.internal_exec = internal_exec
         self.confirm_script = confirm_script
         self.quiet = quiet

webscout-5.3/webscout/DWEBS.py

@@ -0,0 +1,179 @@
+from bs4 import BeautifulSoup
+import requests
+from typing import Dict, List, Optional, Union
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from urllib.parse import quote
+from termcolor import colored
+import time
+import random
+
+class GoogleS:
+    """
+    Class to perform Google searches and retrieve results.
+    """
+
+    def __init__(
+        self,
+        headers: Optional[Dict[str, str]] = None,
+        proxy: Optional[str] = None,
+        timeout: Optional[int] = 10,
+        max_workers: int = 20  # Increased max workers for thread pool
+    ):
+        """Initializes the GoogleS object."""
+        self.proxy = proxy
+        self.headers = headers if headers else {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36 Edg/111.0.1661.62"
+        }
+        self.headers["Referer"] = "https://www.google.com/"
+        self.client = requests.Session()
+        self.client.headers.update(self.headers)
+        self.client.proxies.update({"http": self.proxy, "https": self.proxy})
+        self.timeout = timeout
+        self._executor = ThreadPoolExecutor(max_workers=max_workers) 
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+
+    def _get_url(self, method: str, url: str, params: Optional[Dict[str, str]] = None,
+                  data: Optional[Union[Dict[str, str], bytes]] = None) -> bytes:
+        """
+        Makes an HTTP request and returns the response content.
+        """
+        try:
+            resp = self.client.request(method, url, params=params, data=data, timeout=self.timeout)
+        except Exception as ex:
+            raise Exception(f"{url} {type(ex).__name__}: {ex}") from ex
+        if resp.status_code == 200:
+            return resp.content
+        raise Exception(f"{resp.url} returned status code {resp.status_code}. {params=} {data=}")
+
+    def _extract_text_from_webpage(self, html_content: bytes, max_characters: Optional[int] = None) -> str:
+        """
+        Extracts visible text from HTML content using lxml parser.
+        """
+        soup = BeautifulSoup(html_content, 'lxml')  # Use lxml parser
+        for tag in soup(["script", "style", "header", "footer", "nav"]):
+            tag.extract()
+        visible_text = soup.get_text(strip=True)
+        if max_characters:
+            visible_text = visible_text[:max_characters]
+        return visible_text
+
+    def search(
+        self,
+        query: str,
+        region: str = "us-en",
+        language: str = "en",
+        safe: str = "off",
+        time_period: Optional[str] = None,
+        max_results: int = 10,
+        extract_text: bool = False,
+        max_text_length: Optional[int] = 100,
+    ) -> List[Dict[str, Union[str, int]]]:
+        """
+        Performs a Google search and returns the results.
+
+        Args:
+            query (str): The search query.
+            region (str, optional): The region to search in (e.g., "us-en"). Defaults to "us-en".
+            language (str, optional): The language of the search results (e.g., "en"). Defaults to "en".
+            safe (str, optional): Safe search setting ("off", "active"). Defaults to "off".
+            time_period (Optional[str], optional): Time period filter (e.g., "h" for past hour, "d" for past day). 
+                                                   Defaults to None.
+            max_results (int, optional): The maximum number of results to retrieve. Defaults to 10.
+            extract_text (bool, optional): Whether to extract text from the linked web pages. Defaults to False.
+            max_text_length (Optional[int], optional): The maximum length of the extracted text (in characters). 
+                                                      Defaults to 100.
+
+        Returns:
+            List[Dict[str, Union[str, int]]]: A list of dictionaries, each representing a search result, containing:
+                - 'title': The title of the result.
+                - 'href': The URL of the result.
+                - 'abstract': The description snippet of the result.
+                - 'index': The index of the result in the list.
+                - 'type': The type of result (currently always "web").
+                - 'visible_text': The extracted text from the web page (if `extract_text` is True).
+        """
+        assert query, "Query cannot be empty."
+
+        results = []
+        futures = []
+        start = 0
+
+        while len(results) < max_results:
+            params = {
+                "q": query,
+                "num": 10,
+                "hl": language,
+                "start": start,
+                "safe": safe,
+                "gl": region,
+            }
+            if time_period:
+                params["tbs"] = f"qdr:{time_period}"
+
+            futures.append(self._executor.submit(self._get_url, "GET", "https://www.google.com/search", params=params))
+            start += 10
+
+            for future in as_completed(futures):
+                try:
+                    resp_content = future.result()
+                    soup = BeautifulSoup(resp_content, 'lxml')  # Use lxml parser
+                    result_blocks = soup.find_all("div", class_="g")
+
+                    if not result_blocks:
+                        break
+
+                    # Extract links and titles first
+                    for result_block in result_blocks:
+                        link = result_block.find("a", href=True)
+                        title = result_block.find("h3")
+                        description_box = result_block.find(
+                            "div", {"style": "-webkit-line-clamp:2"}
+                        )
+
+                        if link and title and description_box:
+                            url = link["href"]
+                            results.append({
+                                "title": title.text,
+                                "href": url,
+                                "abstract": description_box.text,
+                                "index": len(results),
+                                "type": "web",
+                                "visible_text": ""  # Initialize visible_text as empty string
+                            })
+
+                            if len(results) >= max_results:
+                                break  # Stop if we have enough results
+
+                    # Parallelize text extraction if needed
+                    if extract_text:
+                        with ThreadPoolExecutor(max_workers=self._executor._max_workers) as text_extractor:
+                            extraction_futures = [
+                                text_extractor.submit(self._extract_text_from_webpage, 
+                                                    self._get_url("GET", result['href']),
+                                                    max_characters=max_text_length)
+                                for result in results 
+                                if 'href' in result
+                            ]
+                            for i, future in enumerate(as_completed(extraction_futures)):
+                                try:
+                                    results[i]['visible_text'] = future.result()
+                                except Exception as e:
+                                    print(f"Error extracting text: {e}")
+
+                except Exception as e:
+                    print(f"Error: {e}")  
+
+        return results
+
+
+if __name__ == "__main__":
+    from rich import print
+    searcher = GoogleS()
+    results = searcher.search("HelpingAI-9B", max_results=20, extract_text=False, max_text_length=200)
+    for result in results:
+        print(result)

webscout-5.3/webscout/Provider/Chatify.py

@@ -0,0 +1,174 @@
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider
+from webscout import exceptions
+import requests
+
+class Chatify(Provider):
+    """
+    A class to interact with the Chatify AI API.
+    """
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        system_prompt: str = "You are a helpful and informative AI assistant.",
+    ):
+        """
+        Initializes the Chatify AI API with given parameters.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_endpoint = "https://chatify-ai.vercel.app/api/chat"
+        self.timeout = timeout
+        self.last_response = {}
+        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://chatify-ai.vercel.app',
+            'Referer': 'https://chatify-ai.vercel.app/',
+            '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-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',
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        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
+        self.session.proxies = proxies
+        self.system_prompt = system_prompt
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """
+        Sends a prompt to the Chatify API and returns the response.
+        """
+        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}"
+                )
+
+        messages = []
+        if self.system_prompt:
+            messages.append({"role": "system", "content": self.system_prompt})
+        messages.append({"role": "user", "content": conversation_prompt})
+
+        payload = {
+            "messages": messages
+        }
+
+        def for_stream():
+            response = self.session.post(self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout)
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            streaming_text = ""
+            for line in response.iter_lines(): 
+                if line:
+                    decoded_line = line.decode('utf-8')  # Decode the line
+                    parts = decoded_line.split(':', 1)
+                    if len(parts) > 1:
+                        content = parts[1].strip().strip('"')
+                        streaming_text += content
+                        yield content if raw else dict(text=streaming_text)
+            self.last_response.update(dict(text=streaming_text))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        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,
+    ) -> str:
+        """
+        Generates a response from the Chatify API.
+        """
+
+        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:
+        """
+        Extracts the message from the API response.
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+# Example usage
+if __name__ == "__main__":
+    from rich import print
+
+    ai = Chatify() 
+    response = ai.chat(input(">>> "))
+    for chunk in response:
+        print(chunk, end="", flush=True)