webscout 3.6__tar.gz → 3.8__tar.gz

{webscout-3.6/webscout.egg-info → webscout-3.8}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.6
-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
+Version: 3.8
+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
 License: HelpingAI
@@ -62,7 +62,7 @@ Provides-Extra: local
 Requires-Dist: llama-cpp-python; extra == "local"
 Requires-Dist: colorama; extra == "local"
 Requires-Dist: numpy; extra == "local"
-Requires-Dist: huggingface_hub; extra == "local"
+Requires-Dist: huggingface_hub[cli]; extra == "local"
 
 <div align="center">
   <!-- Replace `#` with your actual links -->
@@ -1447,13 +1447,19 @@ while True:
     # Print the response
     print("AI: ", response)
 ```
-### `Local-LLM` webscout can now run GGUF models
-Local LLM's some functions are taken from easy-llama
+
+##  Local-LLM
+
+Webscout can now run GGUF models locally. You can download and run your favorite models with minimal configuration.
+
+**Example:**
+
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
 from webscout.Local.thread import Thread
 from webscout.Local import formats
+
 # 1. Download the model
 repo_id = "microsoft/Phi-3-mini-4k-instruct-gguf"  # Replace with the desired Hugging Face repo
 filename = "Phi-3-mini-4k-instruct-q4.gguf" # Replace with the correct filename
@@ -1469,7 +1475,11 @@ thread = Thread(model, formats.phi3)
 thread.interact()
 ```
 
-### `Local-rawdog`
+## Local-rawdog
+Webscout's local raw-dog feature allows you to run Python scripts within your terminal prompt.
+
+**Example:**
+
 ```python
 import webscout.Local as ws
 from webscout.Local.rawdog import RawDog
@@ -1556,6 +1566,63 @@ while True:
         print(script_output)
 
 ```
+
+##  GGUF 
+
+Webscout provides tools to convert and quantize Hugging Face models into the GGUF format for use with offline LLMs.
+
+**Example:**
+
+```python
+from webscout import gguf
+"""
+Valid quantization methods:
+"q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
+"q4_0", "q4_1", "q4_k_m", "q4_k_s", 
+"q5_0", "q5_1", "q5_k_m", "q5_k_s", 
+"q6_k", "q8_0"
+"""
+gguf.convert(
+    model_id="OEvortex/HelpingAI-Lite-1.5T",  # Replace with your model ID
+    username="Abhaykoul",  # Replace with your Hugging Face username
+    token="hf_token_write",  # Replace with your Hugging Face token
+    quantization_methods="q4_k_m"  # Optional, adjust quantization methods
+)
+```
+
+## Autollama
+
+Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
+
+**Example:**
+
+```python
+from webscout import 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
+)
+```
+
+**Command Line Usage:**
+
+* **GGUF Conversion:**
+   ```bash
+   python -m webscout.Extra.gguf -m "OEvortex/HelpingAI-Lite-1.5T" -u "your_username" -t "your_hf_token" -q "q4_k_m,q5_k_m" 
+   ```
+
+* **Autollama:**
+   ```bash
+   python -m webscout.Extra.autollama -m "OEvortex/HelpingAI-Lite-1.5T" -g "HelpingAI-Lite-1.5T.q4_k_m.gguf" 
+   ```
+
+**Note:** 
+
+* Replace `"your_username"` and `"your_hf_token"` with your actual Hugging Face credentials.
+* The `model_path` in `autollama` is the Hugging Face model ID, and `gguf_file` is the GGUF file ID.
+
+
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.6 → webscout-3.8}/README.md

@@ -1381,13 +1381,19 @@ while True:
     # Print the response
     print("AI: ", response)
 ```
-### `Local-LLM` webscout can now run GGUF models
-Local LLM's some functions are taken from easy-llama
+
+##  Local-LLM
+
+Webscout can now run GGUF models locally. You can download and run your favorite models with minimal configuration.
+
+**Example:**
+
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
 from webscout.Local.thread import Thread
 from webscout.Local import formats
+
 # 1. Download the model
 repo_id = "microsoft/Phi-3-mini-4k-instruct-gguf"  # Replace with the desired Hugging Face repo
 filename = "Phi-3-mini-4k-instruct-q4.gguf" # Replace with the correct filename
@@ -1403,7 +1409,11 @@ thread = Thread(model, formats.phi3)
 thread.interact()
 ```
 
-### `Local-rawdog`
+## Local-rawdog
+Webscout's local raw-dog feature allows you to run Python scripts within your terminal prompt.
+
+**Example:**
+
 ```python
 import webscout.Local as ws
 from webscout.Local.rawdog import RawDog
@@ -1490,6 +1500,63 @@ while True:
         print(script_output)
 
 ```
+
+##  GGUF 
+
+Webscout provides tools to convert and quantize Hugging Face models into the GGUF format for use with offline LLMs.
+
+**Example:**
+
+```python
+from webscout import gguf
+"""
+Valid quantization methods:
+"q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
+"q4_0", "q4_1", "q4_k_m", "q4_k_s", 
+"q5_0", "q5_1", "q5_k_m", "q5_k_s", 
+"q6_k", "q8_0"
+"""
+gguf.convert(
+    model_id="OEvortex/HelpingAI-Lite-1.5T",  # Replace with your model ID
+    username="Abhaykoul",  # Replace with your Hugging Face username
+    token="hf_token_write",  # Replace with your Hugging Face token
+    quantization_methods="q4_k_m"  # Optional, adjust quantization methods
+)
+```
+
+## Autollama
+
+Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
+
+**Example:**
+
+```python
+from webscout import 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
+)
+```
+
+**Command Line Usage:**
+
+* **GGUF Conversion:**
+   ```bash
+   python -m webscout.Extra.gguf -m "OEvortex/HelpingAI-Lite-1.5T" -u "your_username" -t "your_hf_token" -q "q4_k_m,q5_k_m" 
+   ```
+
+* **Autollama:**
+   ```bash
+   python -m webscout.Extra.autollama -m "OEvortex/HelpingAI-Lite-1.5T" -g "HelpingAI-Lite-1.5T.q4_k_m.gguf" 
+   ```
+
+**Note:** 
+
+* Replace `"your_username"` and `"your_hf_token"` with your actual Hugging Face credentials.
+* The `model_path` in `autollama` is the Hugging Face model ID, and `gguf_file` is the GGUF file ID.
+
+
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.6 → webscout-3.8}/setup.py

@@ -5,8 +5,8 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="3.6",
-    description="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",
+    version="3.8",
+    description="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",
     long_description=README,
     long_description_content_type="text/markdown",
     author="OEvortex",
@@ -75,7 +75,7 @@ setup(
             'llama-cpp-python',
             'colorama',
             'numpy',
-            'huggingface_hub',
+            'huggingface_hub[cli]',
         ],
     },
     license="HelpingAI",

webscout-3.8/webscout/Extra/__init__.py

@@ -0,0 +1,2 @@
+from .gguf import *
+from .autollama import *

webscout-3.8/webscout/Extra/autollama.py

@@ -0,0 +1,198 @@
+import subprocess
+import argparse
+import os
+
+def autollama(model_path, gguf_file):
+    """Manages models with Ollama using the autollama.sh script.
+
+    Args:
+        model_path (str): The path to the Hugging Face model.
+        gguf_file (str): The name of the GGUF 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
+}
+
+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]
+
+    # Execute the command
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    # Print the output and error in real-time
+    for line in process.stdout:
+        print(line, end='')
+
+    for line in process.stderr:
+        print(line, end='')
+
+    process.wait()
+
+def main():
+    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()
+
+    try:
+        autollama(args.model_path, args.gguf_file)
+    except Exception as e:
+        print(f"Error: {e}")
+        exit(1)
+
+if __name__ == "__main__":
+    main()
+

webscout-3.8/webscout/Extra/gguf.py

@@ -0,0 +1,240 @@
+# webscout/Extra/gguf.py
+import subprocess
+import argparse
+import os 
+
+def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5_k_m"):
+    """Converts and quantizes a Hugging Face model to GGUF format.
+
+    Args:
+        model_id (str): The Hugging Face model ID (e.g., 'google/flan-t5-xl').
+        username (str, optional): Your Hugging Face username. Required for uploads.
+        token (str, optional): Your Hugging Face API token. Required for uploads. 
+        quantization_methods (str, optional): Comma-separated quantization methods. 
+                                                Defaults to "q4_k_m,q5_k_m".
+
+    Raises:
+        ValueError: If an invalid quantization method is provided.
+    """
+
+    # List of valid quantization methods
+    valid_methods = [
+        "q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
+        "q4_0", "q4_1", "q4_k_m", "q4_k_s", 
+        "q5_0", "q5_1", "q5_k_m", "q5_k_s", 
+        "q6_k", "q8_0"
+    ]
+    
+    # Validate the selected quantization methods
+    selected_methods_list = quantization_methods.split(',')
+    for method in selected_methods_list:
+        if method not in valid_methods:
+            raise ValueError(f"Invalid method: {method}. Please select from the available methods: {', '.join(valid_methods)}")
+    
+   # 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
+
+# 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]
+    
+    if username:
+        command.extend(["-u", username])
+    
+    if token:
+        command.extend(["-t", token])
+    
+    if quantization_methods:
+        command.extend(["-q", quantization_methods])
+    
+    # Execute the command
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    # Print the output and error in real-time
+    for line in process.stdout:
+        print(line, end='')
+
+    for line in process.stderr:
+        print(line, end='')
+    
+    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")')
+    parser.add_argument('-u', '--username', help='Set your Hugging Face username (required for uploads)')
+    parser.add_argument('-t', '--token', help='Set your Hugging Face API token (required for uploads)')
+    parser.add_argument('-q', '--quantization_methods', default="q4_k_m,q5_k_m", 
+                        help='Comma-separated quantization methods (default: q4_k_m,q5_k_m). Valid methods: q2_k, q3_k_l, q3_k_m, q3_k_s, q4_0, q4_1, q4_k_m, q4_k_s, q5_0, q5_1, q5_k_m, q5_k_s, q6_k, q8_0')
+    
+    args = parser.parse_args()
+    
+    try:
+        convert(args.model_id, args.username, args.token, args.quantization_methods)
+    except ValueError as e:
+        print(e)
+        exit(1)
+
+if __name__ == "__main__":
+    main()

{webscout-3.6 → webscout-3.8}/webscout/Local/_version.py

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

{webscout-3.6 → webscout-3.8}/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 gguf
+from .Extra import autollama
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 
 webai = [

webscout-3.8/webscout/version.py

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

{webscout-3.6 → webscout-3.8/webscout.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.6
-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
+Version: 3.8
+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
 License: HelpingAI
@@ -62,7 +62,7 @@ Provides-Extra: local
 Requires-Dist: llama-cpp-python; extra == "local"
 Requires-Dist: colorama; extra == "local"
 Requires-Dist: numpy; extra == "local"
-Requires-Dist: huggingface_hub; extra == "local"
+Requires-Dist: huggingface_hub[cli]; extra == "local"
 
 <div align="center">
   <!-- Replace `#` with your actual links -->
@@ -1447,13 +1447,19 @@ while True:
     # Print the response
     print("AI: ", response)
 ```
-### `Local-LLM` webscout can now run GGUF models
-Local LLM's some functions are taken from easy-llama
+
+##  Local-LLM
+
+Webscout can now run GGUF models locally. You can download and run your favorite models with minimal configuration.
+
+**Example:**
+
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
 from webscout.Local.thread import Thread
 from webscout.Local import formats
+
 # 1. Download the model
 repo_id = "microsoft/Phi-3-mini-4k-instruct-gguf"  # Replace with the desired Hugging Face repo
 filename = "Phi-3-mini-4k-instruct-q4.gguf" # Replace with the correct filename
@@ -1469,7 +1475,11 @@ thread = Thread(model, formats.phi3)
 thread.interact()
 ```
 
-### `Local-rawdog`
+## Local-rawdog
+Webscout's local raw-dog feature allows you to run Python scripts within your terminal prompt.
+
+**Example:**
+
 ```python
 import webscout.Local as ws
 from webscout.Local.rawdog import RawDog
@@ -1556,6 +1566,63 @@ while True:
         print(script_output)
 
 ```
+
+##  GGUF 
+
+Webscout provides tools to convert and quantize Hugging Face models into the GGUF format for use with offline LLMs.
+
+**Example:**
+
+```python
+from webscout import gguf
+"""
+Valid quantization methods:
+"q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
+"q4_0", "q4_1", "q4_k_m", "q4_k_s", 
+"q5_0", "q5_1", "q5_k_m", "q5_k_s", 
+"q6_k", "q8_0"
+"""
+gguf.convert(
+    model_id="OEvortex/HelpingAI-Lite-1.5T",  # Replace with your model ID
+    username="Abhaykoul",  # Replace with your Hugging Face username
+    token="hf_token_write",  # Replace with your Hugging Face token
+    quantization_methods="q4_k_m"  # Optional, adjust quantization methods
+)
+```
+
+## Autollama
+
+Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
+
+**Example:**
+
+```python
+from webscout import 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
+)
+```
+
+**Command Line Usage:**
+
+* **GGUF Conversion:**
+   ```bash
+   python -m webscout.Extra.gguf -m "OEvortex/HelpingAI-Lite-1.5T" -u "your_username" -t "your_hf_token" -q "q4_k_m,q5_k_m" 
+   ```
+
+* **Autollama:**
+   ```bash
+   python -m webscout.Extra.autollama -m "OEvortex/HelpingAI-Lite-1.5T" -g "HelpingAI-Lite-1.5T.q4_k_m.gguf" 
+   ```
+
+**Note:** 
+
+* Replace `"your_username"` and `"your_hf_token"` with your actual Hugging Face credentials.
+* The `model_path` in `autollama` is the Hugging Face model ID, and `gguf_file` is the GGUF file ID.
+
+
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.6 → webscout-3.8}/webscout.egg-info/SOURCES.txt

@@ -28,6 +28,9 @@ webscout.egg-info/dependency_links.txt
 webscout.egg-info/entry_points.txt
 webscout.egg-info/requires.txt
 webscout.egg-info/top_level.txt
+webscout/Extra/__init__.py
+webscout/Extra/autollama.py
+webscout/Extra/gguf.py
 webscout/Local/__init__.py
 webscout/Local/_version.py
 webscout/Local/formats.py

{webscout-3.6 → webscout-3.8}/webscout.egg-info/requires.txt

@@ -38,4 +38,4 @@ pytest>=7.4.2
 llama-cpp-python
 colorama
 numpy
-huggingface_hub
+huggingface_hub[cli]

webscout-3.6/webscout/version.py

@@ -1,2 +0,0 @@
-__version__ = "3.4"
-