webscout 2.6__py3-none-any.whl → 2.8__py3-none-any.whl

webscout/Provider/BasedGPT.py

@@ -0,0 +1,226 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+class BasedGPT(Provider):
+    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 = "Be Helpful and Friendly",
+    ):
+        """Instantiates BasedGPT
+
+        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.
+            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.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            system_prompt (str, optional): System prompt for BasedGPT. Defaults to "Be Helpful and Friendly".
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://www.basedgpt.chat/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.system_prompt = system_prompt
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(
+            {"Content-Type": "application/json"}
+        )
+        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
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        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.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        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},
+            ],
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, 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}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    message_load += value
+                    yield value if raw else dict(text=message_load)
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.last_response.update(dict(text=message_load))
+            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:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. 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.
+        Returns:
+            str: Response generated
+        """
+
+        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:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/__init__.py

@@ -28,6 +28,7 @@ from .Gemini import GEMINI
 from .Berlin4h import Berlin4h
 from .ChatGPTUK import ChatGPTUK
 from .Poe import POE
+from .BasedGPT import *
 __all__ = [
     'ThinkAnyAI',
     'Xjai',

webscout/__init__.py

@@ -4,7 +4,7 @@ from .version import __version__
 from .DWEBS import DeepWEBS
 from .transcriber import transcriber
 from .voice import play_audio
-from .tempid import Client as TempMailClient, TemporaryPhoneNumber
+# from .tempid import Client as TempMailClient, TemporaryPhoneNumber
 from .LLM import LLM
 # from .Local import *
 import g4f
@@ -90,4 +90,4 @@ __all__ = [
 ]
 
 import logging
-logging.getLogger("webscout").addHandler(logging.NullHandler())
+logging.getLogger("webscout").addHandler(logging.NullHandler())

webscout/cli.py

@@ -4,12 +4,12 @@ import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from urllib.parse import unquote
-
+from pathlib import Path
 import click
 from curl_cffi import requests
 
 from .webscout_search import WEBS
-from .utils import json_dumps
+from .utils import json_dumps, json_loads
 from .version import __version__
 
 logger = logging.getLogger(__name__)
@@ -129,7 +129,43 @@ def safe_entry_point():
 def version():
     print(__version__)
     return __version__
-
+@cli.command()
+@click.option("-s", "--save", is_flag=True, default=False, help="save the conversation in the json file")
+@click.option("-p", "--proxy", default=None, help="the proxy to send requests, example: socks5://localhost:9150")
+def chat(save, proxy):
+    """CLI function to perform an interactive AI chat using DuckDuckGo API."""
+    cache_file = "WEBS_chat_conversation.json"
+    models = ["gpt-3.5", "claude-3-haiku"]
+    client = WEBS(proxy=proxy)
+
+    print("DuckDuckGo AI chat. Available models:")
+    for idx, model in enumerate(models, start=1):
+        print(f"{idx}. {model}")
+    chosen_model_idx = input("Choose a model by entering its number[1]: ")
+    chosen_model_idx = 0 if not chosen_model_idx.strip() else int(chosen_model_idx) - 1
+    model = models[chosen_model_idx]
+    print(f"Using model: {model}")
+
+    if save and Path(cache_file).exists():
+        with open(cache_file) as f:
+            cache = json_loads(f.read())
+            client._chat_vqd = cache.get("vqd", None)
+            client._chat_messages = cache.get("messages", [])
+
+    while True:
+        user_input = input(f"{'-'*78}\nYou: ")
+        if not user_input.strip():
+            break
+
+        resp_answer = client.chat(keywords=user_input, model=model)
+        text = click.wrap_text(resp_answer, width=78, preserve_paragraphs=True)
+        click.secho(f"AI: {text}", bg="black", fg="green", overline=True)
+
+        cache = {"vqd": client._chat_vqd, "messages": client._chat_messages}
+        _save_json(cache_file, cache)
+
+        if "exit" in user_input.lower() or "quit" in user_input.lower():
+            break
 
 @cli.command()
 @click.option("-k", "--keywords", required=True, help="text search, keywords for query")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "2.0"
+__version__ = "2.7"