webscout 2.5__py3-none-any.whl → 2.7__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/Poe.py

@@ -0,0 +1,208 @@
+from poe_api_wrapper import PoeApi
+from poe_api_wrapper.api import BOTS_LIST
+from ..AIbase import Provider
+from ..AIutel import Conversation
+from ..AIutel  import Optimizers
+from ..AIutel  import AwesomePrompts
+from pathlib import Path
+from json import loads
+from json import dumps
+from loguru import logger
+import logging
+
+logger.remove()
+
+
+class POE(Provider):
+    def __init__(
+        self,
+        cookie: str,
+        model: str = "Assistant",
+        proxy: bool = False,
+        timeout: int = 30,
+        filepath: str = None,
+        update_file: str = True,
+        intro: str = None,
+        act: str = None,
+        init: bool = True,
+    ):
+        """Initializes POE
+
+        Args:
+            cookie (str): Path to `poe.com.cookies.json` file or 'p-b' cookie-value.
+            model (str, optional): Model name. Default to Assistant.
+            proxy (bool, optional): Flag for Httpx request proxy. Defaults to False.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            filepath (str, optional): Path to save the chat history. Defaults to None.
+            update_file (str, optional): Flag for controlling chat history updates. Defaults to True.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            init (bool, optional): Resend the intro prompt. Defaults to True.
+        """
+        assert isinstance(
+            cookie, str
+        ), f"Cookie must be of {str} datatype only not {type(cookie)}"
+        assert (
+            model in BOTS_LIST.keys()
+        ), f"model name '{model}' is not one of {', '.join(list(BOTS_LIST.keys()))}"
+        cookie_path = Path(cookie)
+
+        if cookie_path.exists() or any(["/" in cookie, ".json" in cookie]):
+            cookie = None
+            all_cookies = loads(cookie_path.read_text())
+            for entry in all_cookies:
+                if entry["name"] == "p-b":
+                    cookie = entry["value"]
+            assert (
+                cookie
+            ), f'Required cookie value cannot be retrieved from the path  "{cookie_path.as_posix()}"'
+
+        if proxy:
+            import poe_api_wrapper.proxies as proxies
+
+            proxies.PROXY = True
+
+        self.bot = BOTS_LIST[model]
+        self.session = PoeApi(cookie)
+        self.last_response = {}
+        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(
+            status=False, filepath=filepath, update_file=update_file
+        )
+        if init:
+            self.ask(self.conversation.intro)  # Init
+
+    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]`. Defeaults to None
+                conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            Returns:
+               dict : {}
+        ```json
+        {
+            "id": "TWVzc2FnZToxMTU0MzgyNDQ1ODU=",
+            "messageId": 115438244585,
+            "creationTime": 1707777376544407,
+            "clientNonce": null,
+            "state": "complete",
+            "text": "Hello! How can I assist you today?",
+            "author": "capybara",
+            "contentType": "text_markdown",
+            "sourceType": "chat_input",
+            "attachmentTruncationState": "not_truncated",
+            "attachments": [],
+            "vote": null,
+            "suggestedReplies": [],
+            "hasCitations": false,
+            "__isNode": "Message",
+            "textLengthOnCancellation": null,
+            "chatCode": "21a2jn0yrq9phxiy478",
+            "chatId": 328236777,
+            "title": null,
+            "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}"
+                )
+
+        def for_stream():
+            for response in self.session.send_message(self.bot, conversation_prompt):
+                if raw:
+                    yield dumps(response)
+                else:
+                    yield response
+
+                self.last_response.update(response)
+
+            self.conversation.update_chat_history(
+                prompt,
+                self.get_message(self.last_response),
+                force=True,
+            )
+
+        def for_non_stream():
+            # let's make use of 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

@@ -27,7 +27,8 @@ from .Youchat import YouChat
 from .Gemini import GEMINI
 from .Berlin4h import Berlin4h
 from .ChatGPTUK import ChatGPTUK
-
+from .Poe import POE
+from .BasedGPT import *
 __all__ = [
     'ThinkAnyAI',
     'Xjai',
@@ -56,4 +57,5 @@ __all__ = [
     'GEMINI',
     'Berlin4h',
     'ChatGPTUK',
+    'POE'
 ]

webscout/__init__.py

@@ -4,40 +4,12 @@ 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
 # Import provider classes for direct access
-from .Provider import (
-   ThinkAnyAI,
-   Xjai,
-   LLAMA2, 
-   AsyncLLAMA2,
-   Cohere,
-   REKA,
-   GROQ,
-   AsyncGROQ,
-   OPENAI,
-   AsyncOPENAI,
-   LEO,
-   AsyncLEO,
-   KOBOLDAI,
-   AsyncKOBOLDAI,
-   OPENGPT,
-   AsyncOPENGPT,
-   PERPLEXITY,
-   BLACKBOXAI,
-   AsyncBLACKBOXAI,
-   PhindSearch,
-   AsyncPhindSearch,
-   YEPCHAT,
-   AsyncYEPCHAT,
-   YouChat,
-   GEMINI,
-   Berlin4h,
-   ChatGPTUK,
-)
+from .Provider import *
 
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 
@@ -61,6 +33,7 @@ webai = [
    "berlin4h",
    "chatgptuk",
    "auto",
+   "poe",
 ]
 
 gpt4free_providers = [
@@ -113,7 +86,8 @@ __all__ = [
    "GEMINI",
    "Berlin4h",
    "ChatGPTUK",
+   "POE"
 ]
 
 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"
 

webscout/webai.py

@@ -413,7 +413,23 @@ class Main(cmd.Cmd):
                         "No working g4f provider found. "
                         "Consider running 'webscout gpt4free test -y' first"
                     )
+            elif provider == "poe":
+                assert auth, (
+                    "Path to poe.com.cookies.json file or 'p-b' cookie-value is required. "
+                    "Use the flag `--key` or `-k`"
+                )
+                from webscout import POE
 
+                self.bot = POE(
+                    cookie=auth,
+                    model=getOr(model, "Assistant"),
+                    proxy=bool(proxies),
+                    timeout=timeout,
+                    filepath=filepath,
+                    update_file=update_file,
+                    intro=intro,
+                    act=awesome_prompt,
+                )
             elif provider == "leo":
                 from webscout import LEO