webscout 3.7__py3-none-any.whl → 3.9__py3-none-any.whl

webscout/AIutel.py

@@ -19,7 +19,7 @@ from playsound import playsound
 from time import sleep as wait
 import pathlib
 import urllib.parse
-appdir = appdirs.AppDirs("AIWEBS", "vortex")
+appdir = appdirs.AppDirs("AIWEBS", "webscout")
 
 default_path = appdir.user_cache_dir
 
@@ -49,7 +49,11 @@ webai = [
    "basedgpt",
    "deepseek",
    "deepinfra",
+   "vtlchat",
+   "geminiflash",
+   "geminipro",
 ]
+
 gpt4free_providers = [
     provider.__name__ for provider in g4f.Provider.__providers__  # if provider.working
 ]

webscout/Extra/autollama.py

@@ -10,11 +10,161 @@ def autollama(model_path, gguf_file):
         gguf_file (str): The name of the GGUF file. 
     """
 
-    # Get the directory where this script is located
-    script_dir = os.path.dirname(os.path.abspath(__file__))
+    # Check if autollama.sh exists in the current working directory
+    script_path = os.path.join(os.getcwd(), "autollama.sh")
+    if not os.path.exists(script_path):
+        # Create autollama.sh with the content provided
+        with open(script_path, "w") as f:
+            f.write("""
+function show_art() {
+    cat << "EOF"
+    Made with love in India
+EOF
+}
 
-    # Construct the path to the shell script
-    script_path = os.path.join(script_dir, "autollama.sh") 
+show_art
+
+# Initialize default values
+MODEL_PATH=""
+GGUF_FILE=""
+
+# Display help/usage information
+usage() {
+echo "Usage: $0 -m <model_path> -g <gguf_file>"
+echo
+echo "Options:"
+echo "  -m <model_path>    Set the path to the model"
+echo "  -g <gguf_file>     Set the GGUF file name"
+echo "  -h                 Display this help and exit"
+echo
+}
+
+# Parse command-line options
+while getopts ":m:g:h" opt; do
+case ${opt} in
+    m )
+    MODEL_PATH=$OPTARG
+    ;;
+    g )
+    GGUF_FILE=$OPTARG
+    ;;
+    h )
+    usage
+    exit 0
+    ;;
+    \? )
+    echo "Invalid Option: -$OPTARG" 1>&2
+    usage
+    exit 1
+    ;;
+    : )
+    echo "Invalid Option: -$OPTARG requires an argument" 1>&2
+    usage
+    exit 1
+    ;;
+esac
+done
+
+# Check required parameters
+if [ -z "$MODEL_PATH" ] || [ -z "$GGUF_FILE" ]; then
+    echo "Error: -m (model_path) and -g (gguf_file) are required."
+    usage
+    exit 1
+fi
+
+# Derive MODEL_NAME
+MODEL_NAME=$(echo $GGUF_FILE | sed 's/\(.*\)\.Q4.*/\\1/')
+
+# Log file where downloaded models are recorded
+DOWNLOAD_LOG="downloaded_models.log"
+
+# Composite logging name
+LOGGING_NAME="${MODEL_PATH}_${MODEL_NAME}"
+
+# Check if the model has been downloaded
+function is_model_downloaded {
+    grep -qxF "$LOGGING_NAME" "$DOWNLOAD_LOG" && return 0 || return 1
+}
+
+# Log the downloaded model
+function log_downloaded_model {
+    echo "$LOGGING_NAME" >> "$DOWNLOAD_LOG"
+}
+
+# Function to check if the model has already been created
+function is_model_created {
+    # 'ollama list' lists all models
+    ollama list | grep -q "$MODEL_NAME" && return 0 || return 1
+}
+
+# Check if huggingface-hub is installed, and install it if not
+if ! pip show huggingface-hub > /dev/null; then
+echo "Installing huggingface-hub..."
+pip install -U "huggingface_hub[cli]"
+else
+echo "huggingface-hub is already installed."
+fi
+
+# Check if the model has already been downloaded
+if is_model_downloaded; then
+    echo "Model $LOGGING_NAME has already been downloaded. Skipping download."
+else
+    echo "Downloading model $LOGGING_NAME..."
+    # Download the model
+    huggingface-cli download $MODEL_PATH $GGUF_FILE --local-dir downloads --local-dir-use-symlinks False
+
+    # Log the downloaded model
+    log_downloaded_model
+    echo "Model $LOGGING_NAME downloaded and logged."
+fi
+
+# Check if Ollama is installed, and install it if not
+if ! command -v ollama &> /dev/null; then
+echo "Installing Ollama..."
+curl -fsSL https://ollama.com/install.sh | sh
+else
+echo "Ollama is already installed."
+fi
+
+# Check if Ollama is already running
+if pgrep -f 'ollama serve' > /dev/null; then
+    echo "Ollama is already running. Skipping the start."
+else
+    echo "Starting Ollama..."
+    # Start Ollama in the background
+    ollama serve &
+
+    # Wait for Ollama to start
+    while true; do
+        if pgrep -f 'ollama serve' > /dev/null; then
+            echo "Ollama has started."
+            sleep 60
+            break
+        else
+            echo "Waiting for Ollama to start..."
+            sleep 1 # Wait for 1 second before checking again
+        fi
+    done
+fi
+
+# Check if the model has already been created
+if is_model_created; then
+    echo "Model $MODEL_NAME is already created. Skipping creation."
+else
+    echo "Creating model $MODEL_NAME..."
+    # Create the model in Ollama
+    # Prepare Modelfile with the downloaded path
+    echo "FROM ./downloads/$GGUF_FILE" > Modelfile
+    ollama create $MODEL_NAME -f Modelfile
+    echo "Model $MODEL_NAME created."
+fi
+
+
+echo "model name is > $MODEL_NAME"
+echo "Use Ollama run $MODEL_NAME"
+            """)
+        # Make autollama.sh executable (using chmod)
+        os.chmod(script_path, 0o755)
 
     # Initialize command list
     command = ["bash", script_path, "-m", model_path, "-g", gguf_file]
@@ -32,8 +182,8 @@ def autollama(model_path, gguf_file):
     process.wait()
 
 def main():
-    parser = argparse.ArgumentParser(description='Run autollama.sh to manage models with Ollama')
-    parser.add_argument('-m', '--model_path', required=True, help='Set the path to the Hugging Face model')
+    parser = argparse.ArgumentParser(description='Automatically create and run an Ollama model in Ollama')
+    parser.add_argument('-m', '--model_path', required=True, help='Set the hunggingface model id to the Hugging Face model')
     parser.add_argument('-g', '--gguf_file', required=True, help='Set the GGUF file name')
     args = parser.parse_args()
 
@@ -44,4 +194,5 @@ def main():
         exit(1)
 
 if __name__ == "__main__":
-    main()
+    main()
+

webscout/Extra/gguf.py

@@ -1,3 +1,4 @@
+# webscout/Extra/gguf.py
 import subprocess
 import argparse
 import os 
@@ -30,11 +31,169 @@ def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5
         if method not in valid_methods:
             raise ValueError(f"Invalid method: {method}. Please select from the available methods: {', '.join(valid_methods)}")
     
-    # Get the directory where this script is located
-    script_dir = os.path.dirname(os.path.abspath(__file__))
+   # Construct the absolute path to the shell script
+    script_path = os.path.join(os.getcwd(), "gguf.sh")
+    if not os.path.exists(script_path):
+        # Create autollama.sh with the content provided
+        with open(script_path, "w") as f:
+            f.write("""
+cat << "EOF"
+Made with love in India
+EOF
 
-    # Construct the path to the shell script
-    script_path = os.path.join(script_dir, "gguf.sh")
+# Default values
+MODEL_ID=""
+USERNAME=""
+TOKEN=""
+QUANTIZATION_METHODS="q4_k_m,q5_k_m" # Default to "q4_k_m,q5_k_m" if not provided
+
+# Display help/usage information
+usage() {
+  echo "Usage: $0 -m MODEL_ID [-u USERNAME] [-t TOKEN] [-q QUANTIZATION_METHODS]"
+  echo
+  echo "Options:"
+  echo "  -m MODEL_ID                   Required: Set the HF model ID"
+  echo "  -u USERNAME                   Optional: Set the username"
+  echo "  -t TOKEN                      Optional: Set the token"
+  echo "  -q QUANTIZATION_METHODS       Optional: Set the quantization methods (default: q4_k_m,q5_k_m)"
+  echo "  -h                            Display this help and exit"
+  echo
+}
+
+# Parse command-line options
+while getopts ":m:u:t:q:h" opt; do
+  case ${opt} in
+    m )
+      MODEL_ID=$OPTARG
+      ;;
+    u )
+      USERNAME=$OPTARG
+      ;;
+    t )
+      TOKEN=$OPTARG
+      ;;
+    q )
+      QUANTIZATION_METHODS=$OPTARG
+      ;;
+    h )
+      usage
+      exit 0
+      ;;
+    \? )
+      echo "Invalid Option: -$OPTARG" 1>&2
+      usage
+      exit 1
+      ;;
+    : )
+      echo "Invalid Option: -$OPTARG requires an argument" 1>&2
+      usage
+      exit 1
+      ;;
+  esac
+done
+shift $((OPTIND -1))
+
+# Ensure MODEL_ID is provided
+if [ -z "$MODEL_ID" ]; then
+    echo "Error: MODEL_ID is required."
+    usage
+    exit 1
+fi
+
+# # Echoing the arguments for checking
+# echo "MODEL_ID: $MODEL_ID"
+# echo "USERNAME: ${USERNAME:-'Not provided'}"
+# echo "TOKEN: ${TOKEN:-'Not provided'}"
+# echo "QUANTIZATION_METHODS: $QUANTIZATION_METHODS"
+
+# Splitting string into an array for quantization methods, if provided
+IFS=',' read -r -a QUANTIZATION_METHOD_ARRAY <<< "$QUANTIZATION_METHODS"
+echo "Quantization Methods: ${QUANTIZATION_METHOD_ARRAY[@]}"
+
+MODEL_NAME=$(echo "$MODEL_ID" | awk -F'/' '{print $NF}')
+
+
+# ----------- llama.cpp setup block-----------
+# Check if llama.cpp is already installed and skip the build step if it is
+if [ ! -d "llama.cpp" ]; then
+    echo "llama.cpp not found. Cloning and setting up..."
+    git clone https://github.com/ggerganov/llama.cpp
+    cd llama.cpp && git pull
+    # Install required packages
+    pip3 install -r requirements.txt
+    # Build llama.cpp as it's freshly cloned
+    if ! command -v nvcc &> /dev/null
+    then
+        echo "nvcc could not be found, building llama without LLAMA_CUBLAS"
+        make clean && make
+    else
+        make clean && LLAMA_CUBLAS=1 make
+    fi
+    cd ..
+else
+    echo "llama.cpp found. Assuming it's already built and up to date."
+    # Optionally, still update dependencies
+    # cd llama.cpp && pip3 install -r requirements.txt && cd ..
+fi
+# ----------- llama.cpp setup block-----------
+
+
+
+
+# Download model 
+#todo : shall we put condition to check if model has been already downloaded? similar to autogguf?
+echo "Downloading the model..."
+huggingface-cli download "$MODEL_ID" --local-dir "./${MODEL_NAME}" --local-dir-use-symlinks False --revision main
+
+
+# Convert to fp16
+FP16="${MODEL_NAME}/${MODEL_NAME,,}.fp16.bin"
+echo "Converting the model to fp16..."
+python3 llama.cpp/convert-hf-to-gguf.py "$MODEL_NAME" --outtype f16 --outfile "$FP16"
+
+# Quantize the model
+echo "Quantizing the model..."
+for METHOD in "${QUANTIZATION_METHOD_ARRAY[@]}"; do
+    QTYPE="${MODEL_NAME}/${MODEL_NAME,,}.${METHOD^^}.gguf"
+    ./llama.cpp/llama-quantize "$FP16" "$QTYPE" "$METHOD"
+done
+
+
+# Check if USERNAME and TOKEN are provided
+if [[ -n "$USERNAME" && -n "$TOKEN" ]]; then
+
+    # Login to Hugging Face
+    echo "Logging in to Hugging Face..."
+    huggingface-cli login --token "$TOKEN"
+
+
+    # Uploading .gguf, .md files, and config.json
+    echo "Uploading .gguf, .md files, and config.json..."
+
+
+    # Define a temporary directory
+    TEMP_DIR="./temp_upload_dir"
+
+    # Create the temporary directory
+    mkdir -p "${TEMP_DIR}"
+
+    # Copy the specific files to the temporary directory
+    find "./${MODEL_NAME}" -type f \( -name "*.gguf" -o -name "*.md" -o -name "config.json" \) -exec cp {} "${TEMP_DIR}/" \;
+
+    # Upload the temporary directory to Hugging Face
+    huggingface-cli upload "${USERNAME}/${MODEL_NAME}-GGUF" "${TEMP_DIR}" --private
+
+    # Remove the temporary directory after upload
+    rm -rf "${TEMP_DIR}"
+    echo "Upload completed."
+else
+    echo "USERNAME and TOKEN must be provided for upload."
+fi
+
+echo "Script completed."
+            """)
+        # Make autollama.sh executable (using chmod)
+        os.chmod(script_path, 0o755)
 
     # Construct the command
     command = ["bash", script_path, "-m", model_id]
@@ -60,6 +219,7 @@ def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5
     
     process.wait()
 
+
 def main():
     parser = argparse.ArgumentParser(description='Convert and quantize model using gguf.sh')
     parser.add_argument('-m', '--model_id', required=True, help='Set the HF model ID (e.g., "google/flan-t5-xl")')

webscout/Local/_version.py

@@ -1,3 +1,3 @@
 from llama_cpp import __version__ as __llama_cpp_version__
 
-__version__ = '3.7'
+__version__ = '3.9'

webscout/Provider/Geminiflash.py

@@ -0,0 +1,152 @@
+import requests
+from ..AIbase import Provider
+from ..AIutel import Conversation
+from ..AIutel import Optimizers
+from ..AIutel import AwesomePrompts
+from webscout import exceptions
+
+class GEMINIFLASH(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,
+    ):
+        """Initializes GEMINI
+
+        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.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://gemini-flash.developer-house.workers.dev"
+        self.timeout = timeout
+        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(
+            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
+        {
+           "text" : "How may I assist you today?"
+        }
+        ```
+        """
+        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}"
+                )
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+            }
+        )
+        payload = {"question": conversation_prompt}
+
+        response = self.session.get(
+            self.chat_endpoint, params=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}"
+            )
+        
+        resp = response.json()
+        self.last_response.update(resp)
+        self.conversation.update_chat_history(
+            prompt, self.get_message(self.last_response)
+        )
+        return resp
+
+    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
+        """
+        return self.get_message(
+            self.ask(
+                prompt,
+                optimizer=optimizer,
+                conversationally=conversationally,
+            )
+        )
+
+    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"
+        try:
+            return response["content"]
+        except KeyError:
+            return ""

webscout/Provider/Geminipro.py

@@ -0,0 +1,152 @@
+import requests
+from ..AIbase import Provider
+from ..AIutel import Conversation
+from ..AIutel import Optimizers
+from ..AIutel import AwesomePrompts
+from webscout import exceptions
+
+class GEMINIPRO(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,
+    ):
+        """Initializes GEMINI
+
+        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.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://gemini-pro.developer-house.workers.dev/"
+        self.timeout = timeout
+        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(
+            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
+        {
+           "text" : "How may I assist you today?"
+        }
+        ```
+        """
+        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}"
+                )
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+            }
+        )
+        payload = {"question": conversation_prompt}
+
+        response = self.session.get(
+            self.chat_endpoint, params=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}"
+            )
+        
+        resp = response.json()
+        self.last_response.update(resp)
+        self.conversation.update_chat_history(
+            prompt, self.get_message(self.last_response)
+        )
+        return resp
+
+    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
+        """
+        return self.get_message(
+            self.ask(
+                prompt,
+                optimizer=optimizer,
+                conversationally=conversationally,
+            )
+        )
+
+    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"
+        try:
+            return response["content"]
+        except KeyError:
+            return ""

webscout/Provider/Youchat.py

@@ -218,4 +218,8 @@ class YouChat(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__":
+    YouChat = YouChat()
+    print(YouChat.chat("hello"))

webscout/Provider/__init__.py

@@ -35,6 +35,9 @@ from .BasedGPT import BasedGPT
 from .Deepseek import DeepSeek
 from .Deepinfra import DeepInfra, VLM, AsyncDeepInfra
 from .VTLchat import VTLchat
+from .Geminipro import GEMINIPRO
+from .Geminiflash import GEMINIFLASH
+
 __all__ = [
     'ThinkAnyAI',
     'Xjai',
@@ -73,5 +76,8 @@ __all__ = [
     'AsyncPhindv2',
     'Phindv2',
     'OPENGPTv2',
+    'GEMINIPRO',
+    'GEMINIFLASH',
+
 
 ]

webscout/__init__.py

@@ -11,7 +11,8 @@ from .LLM import LLM
 import g4f
 # Import provider classes for direct access
 from .Provider import *
-from .Extra import *
+from .Extra import gguf
+from .Extra import autollama
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 
 webai = [
@@ -38,6 +39,9 @@ webai = [
    "basedgpt",
    "deepseek",
    "deepinfra",
+   "vtlchat",
+   "geminiflash",
+   "geminipro",
 ]
 
 gpt4free_providers = [

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "3.7"
+__version__ = "3.9"
 

webscout/webai.py

@@ -689,7 +689,55 @@ class Main(cmd.Cmd):
                     history_offset=history_offset,
                     act=awesome_prompt,
                 )
+            elif provider == "geminiflash":
+                from webscout import GEMINIFLASH
 
+                self.bot = GEMINIFLASH(
+                    is_conversation=disable_conversation,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    timeout=timeout,
+                    intro=intro,
+                    filepath=filepath,
+                    update_file=update_file,
+                    proxies=proxies,
+                    history_offset=history_offset,
+                    act=awesome_prompt,
+                )
+            elif provider == "geminipro":
+                from webscout import GEMINIPRO
+
+                self.bot = GEMINIPRO(
+                    is_conversation=disable_conversation,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    timeout=timeout,
+                    intro=intro,
+                    filepath=filepath,
+                    update_file=update_file,
+                    proxies=proxies,
+                    history_offset=history_offset,
+                    act=awesome_prompt,
+                )
+
+            elif provider == "vtlchat":
+                from webscout import VTLchat
+
+                self.bot = VTLchat(
+                    is_conversation=disable_conversation,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    timeout=timeout,
+                    intro=intro,
+                    filepath=filepath,
+                    update_file=update_file,
+                    proxies=proxies,
+                    history_offset=history_offset,
+                    act=awesome_prompt,
+                )
             elif provider == "gemini":
                 from webscout import GEMINI
 

{webscout-3.7.dist-info → webscout-3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.7
+Version: 3.9
 Summary: Search for anything using Google, DuckDuckGo, brave, qwant,  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
@@ -1421,6 +1421,9 @@ provider = VTLchat()
 response = provider.chat("Hello, how are you?")
 print(response)
 ```
+
+### 21. GeminiFlash and geminipro
+**Usage similar to other providers**
 ### `LLM` 
 ```python
 from webscout.LLM import LLM
@@ -1599,7 +1602,7 @@ Webscout's `autollama` utility download model from huggingface and then automati
 ```python
 from webscout import autollama
 
-autollama.autollama(
+autollama(
     model_path="OEvortex/HelpingAI-Lite-1.5T",  # Hugging Face model ID
     gguf_file="HelpingAI-Lite-1.5T.q4_k_m.gguf" #  GGUF file ID
 )
@@ -1698,335 +1701,7 @@ if __name__ == "__main__":
 ```
 
 ## `Webai` - terminal gpt and a open interpeter
-
-```python
-import time
-import uuid
-from typing import Dict, Any, Optional, AsyncGenerator
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.style import Style
-import webscout
-import webscout.AIutel
-import g4f
-from webscout.g4f import *
-from webscout.async_providers import mapper as async_provider_map
-
-class TaskExecutor:
-    """
-    Manages an interactive chat session, handling user input, AI responses, 
-    and optional features like web search, code execution, and text-to-speech.
-    """
-
-    def __init__(self) -> None:
-        """Initializes the conversational assistant with default settings."""
-        self._console: Console = Console()
-
-        # Session configuration
-        self._selected_provider: str = "phind"
-        self._selected_model: str = "Phind Model"
-        self._conversation_enabled: bool = True
-        self._max_tokens: int = 600
-        self._temperature: float = 0.2
-        self._top_k: int = -1
-        self._top_p: float = 0.999
-        self._timeout: int = 30
-        self._auth_token: str = None  # API key, if required
-        self._chat_completion_enabled: bool = True  # g4fauto
-        self._ignore_working: bool = False  # Ignore working status of providers
-        self._proxy_path: str = None  # Path to proxy configuration
-
-        # History Management
-        self._history_filepath: str = "history.txt"
-        self._update_history_file: bool = True
-        self._history_offset: int = 10250
-
-        # Prompt Engineering
-        self._initial_prompt: str = None
-        self._awesome_prompt_content: str = None 
-
-        # Optional Features
-        self._web_search_enabled: bool = False  # Enable web search
-        self._rawdog_enabled: bool = True
-        self._internal_script_execution_enabled: bool = True
-        self._script_confirmation_required: bool = False
-        self._selected_interpreter: str = "python"
-        self._selected_optimizer: str = "code"
-        self._suppress_output: bool = False  # Suppress verbose output
-
-        # AI provider mapping
-        self._ai_provider_mapping: Dict[str, Any] = {
-            "phind": webscout.PhindSearch,
-            "opengpt": webscout.OPENGPT,
-            "koboldai": webscout.KOBOLDAI,
-            "blackboxai": webscout.BLACKBOXAI,
-            "llama2": webscout.LLAMA2,
-            "yepchat": webscout.YEPCHAT,
-            "leo": webscout.LEO,
-            "groq": webscout.GROQ,
-            "openai": webscout.OPENAI,
-            "perplexity": webscout.PERPLEXITY,
-            "you": webscout.YouChat,
-            "xjai": webscout.Xjai,
-            "cohere": webscout.Cohere,
-            "reka": webscout.REKA,
-            "thinkany": webscout.ThinkAnyAI,
-            "gemini": webscout.GEMINI, 
-            "berlin4h": webscout.Berlin4h,
-            "chatgptuk": webscout.ChatGPTUK,
-            "poe": webscout.POE,
-            "basedgpt": webscout.BasedGPT,
-            "deepseek": webscout.DeepSeek,
-            "deepinfra": webscout.DeepInfra,
-            "opengenptv2": webscout.OPENGPTv2
-        }
-
-        # Initialize Rawdog if enabled
-        if self._rawdog_enabled:
-            self._rawdog_instance: webscout.AIutel.RawDog = webscout.AIutel.RawDog(
-                quiet=self._suppress_output,
-                internal_exec=self._internal_script_execution_enabled,
-                confirm_script=self._script_confirmation_required,
-                interpreter=self._selected_interpreter,
-            )
-
-            self._initial_prompt = self._rawdog_instance.intro_prompt
-
-        # Initialize the selected AI model 
-        self._ai_model = self._get_ai_model()
-
-    def _get_ai_model(self):
-        """
-        Determines the appropriate AI model based on the selected provider, 
-        including automatic provider selection and g4fauto support.
-        """
-        if self._selected_provider == "g4fauto":
-            # Automatically select the best provider from g4f
-            test = TestProviders(quiet=self._suppress_output, timeout=self._timeout)
-            g4fauto = test.best if not self._ignore_working else test.auto
-            if isinstance(g4fauto, str):
-                self._selected_provider = "g4fauto+" + g4fauto
-                self._ai_model = self._create_g4f_model(g4fauto)
-            else:
-                raise Exception(
-                    "No working g4f provider found. "
-                    "Consider running 'webscout.webai gpt4free test -y' first"
-                )
-        else:
-            # Use the specified provider
-            self._ai_model = self._ai_provider_mapping[self._selected_provider](
-                is_conversation=self._conversation_enabled,
-                max_tokens=self._max_tokens,
-                timeout=self._timeout,
-                intro=self._initial_prompt,
-                filepath=self._history_filepath,
-                update_file=self._update_history_file,
-                proxies={},  # Load proxies from config if needed
-                history_offset=self._history_offset,
-                act=self._awesome_prompt_content, 
-                model=self._selected_model,
-                quiet=self._suppress_output,
-                # auth=self._auth_token,  # Pass API key if required
-            )
-        return self._ai_model
-
-    def _create_g4f_model(self, provider: str):
-        """
-        Creates a g4f model instance using the provided provider and webscout.WEBS for web search.
-        """
-        return webscout.g4f.GPT4FREE(
-            provider=provider,
-            auth=self._auth_token,
-            max_tokens=self._max_tokens,
-            chat_completion=self._chat_completion_enabled,
-            ignore_working=self._ignore_working,
-            timeout=self._timeout,
-            intro=self._initial_prompt,
-            filepath=self._history_filepath,
-            update_file=self._update_history_file,
-            proxies={},  # Load proxies from config if needed
-            history_offset=self._history_offset,
-            act=self._awesome_prompt_content, 
-        )
-
-    def process_query(self, query: str) -> None:
-        """
-        Processes a user query, potentially enhancing it with web search results, 
-        passing it to the AI model, and handling the response.
-
-        Args:
-            query: The user's text input.
-
-        Returns:
-            None
-        """
-        if self._web_search_enabled:
-            query = self._augment_query_with_web_search(query)
-
-        # Apply code optimization if configured
-        if self._selected_optimizer == "code":
-            query = webscout.AIutel.Optimizers.code(query)
-
-        try:
-            response: str = self._ai_model.chat(query)
-        except webscout.exceptions.FailedToGenerateResponseError as e:
-            self._console.print(Markdown(f"LLM: [red]{e}[/red]"))
-            return
-
-        # Handle Rawdog responses if enabled
-        if self._rawdog_enabled:
-            self._handle_rawdog_response(response)
-        else:
-            self._console.print(Markdown(f"LLM: {response}"))
-
-    def _augment_query_with_web_search(self, query: str) -> str:
-        """Performs a web search and appends the results to the query.
-
-        Args:
-            query: The user's text input.
-
-        Returns:
-            str: The augmented query with web search results.
-        """
-        web_search_results = webscout.WEBS().text(query, max_results=3)
-        if web_search_results:
-            formatted_results = "\n".join(
-                f"{i+1}. {result['title']} - {result['href']}\n\nBody: {result['body']}"
-                for i, result in enumerate(web_search_results)
-            )
-            query += f"\n\n## Web Search Results are:\n\n{formatted_results}"
-        return query
-
-    def _handle_rawdog_response(self, response: str) -> None:
-        """Handles AI responses, potentially executing them as code with Rawdog.
-
-        Args:
-            response: The AI model's response.
-
-        Returns:
-            None
-        """
-        try:
-            is_feedback = self._rawdog_instance.main(response)
-            if is_feedback and "PREVIOUS SCRIPT EXCEPTION" in is_feedback:
-                self._console.print(Markdown(f"LLM: {is_feedback}"))
-                error_message = is_feedback.split("PREVIOUS SCRIPT EXCEPTION:\n")[1].strip()
-                # Generate a solution for the error and execute it
-                error_solution_query = (
-                    f"The following code was executed and resulted in an error:\n\n"
-                    f"{response}\n\n"
-                    f"Error: {error_message}\n\n"
-                    f"Please provide a solution to fix this error in the code and execute it."
-                )
-                try:
-                    new_response = self._ai_model.chat(error_solution_query)
-                    self._handle_rawdog_response(new_response)
-                except webscout.exceptions.FailedToGenerateResponseError as e:
-                    self._console.print(Markdown(f"LLM: [red]Error while generating solution: {e}[/red]"))
-            else:
-                self._console.print(Markdown("LLM: (Script executed successfully)"))
-        except Exception as e:
-            self._console.print(Markdown(f"LLM: [red]Error: {e}[/red]"))
-
-
-    async def process_async_query(self, query: str) -> None:
-        """
-        Asynchronously processes a user query, potentially enhancing it with web search results, 
-        passing it to the AI model, and handling the response.
-
-        Args:
-            query: The user's text input.
-
-        Returns:
-            None
-        """
-        if self._web_search_enabled:
-            query = self._augment_query_with_web_search(query)
-
-        # Apply code optimization if configured
-        if self._selected_optimizer == "code":
-            query = webscout.AIutel.Optimizers.code(query)
-
-        async_model = self._get_async_ai_model()
-
-        try:
-            async for response in async_model.chat(query, stream=True):
-                self._console.print(Markdown(f"LLM: {response}"), end="")
-        except webscout.exceptions.FailedToGenerateResponseError as e:
-            self._console.print(Markdown(f"LLM: [red]{e}[/red]"))
-            return
-
-        # Handle Rawdog responses if enabled
-        if self._rawdog_enabled:
-            self._handle_rawdog_response(response)
-        else:
-            self._console.print(Markdown(f"LLM: {response}"))
-
-    def _get_async_ai_model(self):
-        """
-        Determines the appropriate asynchronous AI model based on the selected provider.
-        """
-        if self._selected_provider == "g4fauto":
-            # Automatically select the best provider from g4f
-            test = TestProviders(quiet=self._suppress_output, timeout=self._timeout)
-            g4fauto = test.best if not self._ignore_working else test.auto
-            if isinstance(g4fauto, str):
-                self._selected_provider = "g4fauto+" + g4fauto
-                self._ai_model = self._create_async_g4f_model(g4fauto)
-            else:
-                raise Exception(
-                    "No working g4f provider found. "
-                    "Consider running 'webscout gpt4free test -y' first"
-                )
-        else:
-            # Use the specified provider
-            if self._selected_provider in async_provider_map:
-                self._ai_model = async_provider_map[self._selected_provider](
-                    is_conversation=self._conversation_enabled,
-                    max_tokens=self._max_tokens,
-                    timeout=self._timeout,
-                    intro=self._initial_prompt,
-                    filepath=self._history_filepath,
-                    update_file=self._update_history_file,
-                    proxies={},  # Load proxies from config if needed
-                    history_offset=self._history_offset,
-                    act=self._awesome_prompt_content, 
-                    model=self._selected_model,
-                    quiet=self._suppress_output,
-                    auth=self._auth_token,  # Pass API key if required
-                )
-            else:
-                raise Exception(
-                    f"Asynchronous provider '{self._selected_provider}' is not yet supported"
-                )
-        return self._ai_model
-
-    def _create_async_g4f_model(self, provider: str):
-        """
-        Creates an asynchronous g4f model instance using the provided provider and webscout.WEBS for web search.
-        """
-        return webscout.g4f.AsyncGPT4FREE(
-            provider=provider,
-            auth=self._auth_token,
-            max_tokens=self._max_tokens,
-            chat_completion=self._chat_completion_enabled,
-            ignore_working=self._ignore_working,
-            timeout=self._timeout,
-            intro=self._initial_prompt,
-            filepath=self._history_filepath,
-            update_file=self._update_history_file,
-            proxies={},  # Load proxies from config if needed
-            history_offset=self._history_offset,
-            act=self._awesome_prompt_content,
-        )
-
-if __name__ == "__main__":
-    assistant = TaskExecutor()
-    while True:
-        input_query = input("Enter your query: ")
-        assistant.process_query(input_query)
-
+Code is in rawdog.py file
 ```
 ```shell
 python -m webscout.webai webai --provider "phind" --rawdog

{webscout-3.7.dist-info → webscout-3.9.dist-info}/RECORD

@@ -1,9 +1,9 @@
 webscout/AIauto.py,sha256=xPGr_Z0h27XXNh4Wiufjn9TksDOqxqlaGcLUYKNP55w,18246
 webscout/AIbase.py,sha256=GoHbN8r0gq2saYRZv6LA-Fr9Jlcjv80STKFXUq2ZeGU,4710
-webscout/AIutel.py,sha256=MMfUvTQXYDtaFXsXtwKgv9V_qMK6WgOxdx7Wagdm2Lw,33542
+webscout/AIutel.py,sha256=akfyVlJnIdo8jf8c1vzKDITtNdwAJHFqC5bEVGh7554,33597
 webscout/DWEBS.py,sha256=QLuT1IKu0lnwdl7W6c-ctBAO7Jj0Zk3PYm6-13BC7rU,25740
 webscout/LLM.py,sha256=LbGCZdJf8A5dwfoGS4tyy39tAh5BDdhMZP0ScKaaQfU,4184
-webscout/__init__.py,sha256=WolS-VvktY4VezczjfbZuZR5iPCtCzPUV_WKqDFVIoA,2058
+webscout/__init__.py,sha256=znxNHlt9EDBgWP1uD71EN9eKO4-WFpmN8_bPPmJaNLw,2142
 webscout/__main__.py,sha256=ZtTRgsRjUi2JOvYFLF1ZCh55Sdoz94I-BS-TlJC7WDU,126
 webscout/async_providers.py,sha256=holBv5SxanxVXc_92CBBaXHlB2IakB_fHnhyZaFjYF8,684
 webscout/cli.py,sha256=enw_dPTCG3sNC1TXt96XccnpRmF4Etr99nh-RbGYags,18784
@@ -13,17 +13,17 @@ webscout/models.py,sha256=5iQIdtedT18YuTZ3npoG7kLMwcrKwhQ7928dl_7qZW0,692
 webscout/tempid.py,sha256=5oc3UbXhPGKxrMRTfRABT-V-dNzH_hOKWtLYM6iCWd4,5896
 webscout/transcriber.py,sha256=EddvTSq7dPJ42V3pQVnGuEiYQ7WjJ9uyeR9kMSxN7uY,20622
 webscout/utils.py,sha256=CxeXvp0rWIulUrEaPZMaNfg_tSuQLRSV8uuHA2chyKE,2603
-webscout/version.py,sha256=IuTIikIXiglYKmugXFivfp0USNzx9FUxd_CVlae9bgk,23
+webscout/version.py,sha256=-NWv4nLXKlNPAmvsqgPMnu9sdeUQAtJ95GCckHBql6M,23
 webscout/voice.py,sha256=0QjXTHAQmCK07IDZXRc7JXem47cnPJH7u3X0sVP1-UQ,967
-webscout/webai.py,sha256=qkvhYdyF5wNdmW4rNdH3RbfQxabEWlGvCyAk2SbH04k,86602
+webscout/webai.py,sha256=Bs6HtPAxupTsUmuCGlylYQ325EDuYjFTJgmnbe5Gj5w,88471
 webscout/webscout_search.py,sha256=lFAot1-Qil_YfXieeLakDVDEX8Ckcima4ueXdOYwiMc,42804
 webscout/webscout_search_async.py,sha256=dooKGwLm0cwTml55Vy6NHPPY-nymEqX2h8laX94Zg5A,14537
 webscout/websx_search.py,sha256=n-qVwiHozJEF-GFRPcAfh4k1d_tscTmDe1dNL-1ngcU,12094
 webscout/Extra/__init__.py,sha256=vlW4RoSl5v3d7j_Yq1XEMydrG9JM-On_afgK-HtRZsk,45
-webscout/Extra/autollama.py,sha256=5OPVRETbRJomTerddMJtznE-GFAZvDx5BPRM9EQB9dU,1476
-webscout/Extra/gguf.py,sha256=HrRF0hW3HZHwtu4OCFumlRTgMBqFpqK0JKyRTRyPWrs,3122
+webscout/Extra/autollama.py,sha256=DDdnb1tKEZWJaADVn9GXTZkMSwLKCcUGIjMKNlOBtK8,5419
+webscout/Extra/gguf.py,sha256=5zTNE5HxM_VQ5ONoocL8GG5fRXrgyLdEEjNzndG0oUw,7811
 webscout/Local/__init__.py,sha256=RN6klpbabPGNX2YzPm_hdeUcQvieUwvJt22uAO2RKSM,238
-webscout/Local/_version.py,sha256=3sFn1tDa2mT9Pb1-OGW4K3_zbiJ0mhPRqB2rnLfp28Q,83
+webscout/Local/_version.py,sha256=J-XfaHI4CMBbIor8FPDPPUHW5Q1Y8wrhkVocEjQJ0qg,83
 webscout/Local/formats.py,sha256=BiZZSoN3e8S6-S-ykBL9ogSUs0vK11GaZ3ghc9U8GRk,18994
 webscout/Local/model.py,sha256=T_bzNNrxEyOyLyhp6fKwiuVBBkXC2a37LzJVCxFIxOU,30710
 webscout/Local/rawdog.py,sha256=ojY_O8Vb1KvR34OwWdfLgllgaAK_7HMf64ElMATvCXs,36689
@@ -38,6 +38,8 @@ webscout/Provider/Cohere.py,sha256=IXnRosYOaMAA65nvsKmN6ZkJGSdZFYQYBidzuNaCqX8,8
 webscout/Provider/Deepinfra.py,sha256=kVnWARJdEtIeIsZwGw3POq8B2dO87bDcJso3uOeCeOA,18750
 webscout/Provider/Deepseek.py,sha256=pnOB44ObuOfAsoi_bUGUvha3tfwd0rTJ9rnX-14QkL4,10550
 webscout/Provider/Gemini.py,sha256=_4DHWvlWuNAmVHPwHB1RjmryjTZZCthLa6lvPEHLvkQ,8451
+webscout/Provider/Geminiflash.py,sha256=1kMPA-ypi1gmJoms606Z7j_51znpdofM2aAyo4Hl7wU,5951
+webscout/Provider/Geminipro.py,sha256=nOifT5CRmnUg28iifSbOHkNLoKucLRr5zCj607mVrhw,5948
 webscout/Provider/Groq.py,sha256=QfgP3hKUcqq5vUA4Pzuu3HAgpJkKwLWNjjsnxtkCYd8,21094
 webscout/Provider/Koboldai.py,sha256=KwWx2yPlvT9BGx37iNvSbgzWkJ9I8kSOmeg7sL1hb0M,15806
 webscout/Provider/Leo.py,sha256=wbuDR-vFjLptfRC6yDlk74tINqNvCOzpISsK92lIgGg,19987
@@ -52,11 +54,11 @@ webscout/Provider/ThinkAnyAI.py,sha256=_qFjj0djxxrranyEY33w14oizyRjzlVwMv_hzvVtw
 webscout/Provider/VTLchat.py,sha256=_sErGr-wOi16ZAfiGOo0bPsAEMkjzzwreEsIqjIZMIU,10041
 webscout/Provider/Xjai.py,sha256=BIlk2ouz9Kh_0Gg9hPvTqhI7XtcmWdg5vHSX_4uGrIs,9039
 webscout/Provider/Yepchat.py,sha256=2Eit-A7w1ph1GQKNQuur_yaDzI64r0yBGxCIjDefJxQ,19875
-webscout/Provider/Youchat.py,sha256=UVGBuGSjv4uRibn1xflmCjYcfrRTKnDvX3adhag6T98,7976
-webscout/Provider/__init__.py,sha256=RaMdtYv7eQJ2vB8jXUHrkfNbx2DgRjbwc6DI40cOH1A,1809
-webscout-3.7.dist-info/LICENSE.md,sha256=9P0imsudI7MEvZe2pOcg8rKBn6E5FGHQ-riYozZI-Bk,2942
-webscout-3.7.dist-info/METADATA,sha256=FocHEEpfWeT2aX3bUXJ8mHw1cWugF3tijDNqUnehB-o,69115
-webscout-3.7.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-webscout-3.7.dist-info/entry_points.txt,sha256=Hh4YIIjvkqB9SVxZ2ri4DZUkgEu_WF_5_r_nZDIvfG8,73
-webscout-3.7.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
-webscout-3.7.dist-info/RECORD,,
+webscout/Provider/Youchat.py,sha256=fhMpt94pIPE_XDbC4z9xyfgA7NbkNE2wlRFJabsjv90,8069
+webscout/Provider/__init__.py,sha256=nFRM7vno2a7y2lG-7mDXvzytI8irb_loC0BPGZtrh7w,1923
+webscout-3.9.dist-info/LICENSE.md,sha256=9P0imsudI7MEvZe2pOcg8rKBn6E5FGHQ-riYozZI-Bk,2942
+webscout-3.9.dist-info/METADATA,sha256=BGlQ0WLKmc-jx8j7dQhYR_tM8IZGORpTSWqEzSKYlSk,55625
+webscout-3.9.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+webscout-3.9.dist-info/entry_points.txt,sha256=Hh4YIIjvkqB9SVxZ2ri4DZUkgEu_WF_5_r_nZDIvfG8,73
+webscout-3.9.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-3.9.dist-info/RECORD,,