webscout 4.3__tar.gz → 4.4__tar.gz

{webscout-4.3/webscout.egg-info → webscout-4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.3
+Version: 4.4
 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
@@ -34,6 +34,7 @@ Requires-Dist: tqdm
 Requires-Dist: webdriver-manager
 Requires-Dist: halo>=0.0.31
 Requires-Dist: g4f>=0.2.2.3
+Requires-Dist: g4f[webdriver]
 Requires-Dist: rich
 Requires-Dist: python-dotenv
 Requires-Dist: beautifulsoup4
@@ -55,6 +56,11 @@ Requires-Dist: playsound
 Requires-Dist: poe_api_wrapper
 Requires-Dist: pyreqwest_impersonate
 Requires-Dist: ballyregan
+Requires-Dist: nodriver
+Requires-Dist: PyExecJS
+Requires-Dist: ollama
+Requires-Dist: pyfiglet
+Requires-Dist: yaspin
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.6; extra == "dev"
 Requires-Dist: pytest>=7.4.2; extra == "dev"

{webscout-4.3 → webscout-4.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="4.3",
+    version="4.4",
     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",
@@ -38,6 +38,7 @@ setup(
         "webdriver-manager",
         "halo>=0.0.31",
         "g4f>=0.2.2.3",
+        "g4f[webdriver]",
         "rich",
         "python-dotenv",
         "beautifulsoup4",
@@ -58,7 +59,12 @@ setup(
         "playsound",
         "poe_api_wrapper",
         "pyreqwest_impersonate",
-        "ballyregan"
+        "ballyregan",
+        "nodriver",
+        "PyExecJS",
+        "ollama",
+        "pyfiglet",
+        "yaspin",
     ],
     entry_points={
         "console_scripts": [

{webscout-4.3 → webscout-4.4}/webscout/AIauto.py

@@ -1,8 +1,7 @@
 from webscout.AIbase import Provider, AsyncProvider
 from webscout.Provider.ThinkAnyAI import ThinkAnyAI
 from webscout.Provider.Xjai import Xjai
-from webscout.Provider.Llama import LLAMA2
-from webscout.Provider.Llama import AsyncLLAMA2
+from webscout.Provider.Llama import LLAMA
 from webscout.Provider.Leo import LEO
 from webscout.Provider.Leo import AsyncLEO
 from webscout.Provider.Koboldai import KOBOLDAI
@@ -44,7 +43,7 @@ provider_map: dict[
     Union[
         ThinkAnyAI,
         Xjai,
-        LLAMA2,
+        LLAMA,
         LEO,
         KOBOLDAI,
         OPENGPT,
@@ -69,7 +68,7 @@ provider_map: dict[
 ] = {
     "ThinkAnyAI": ThinkAnyAI,
     "Xjai": Xjai,
-    "LLAMA2": LLAMA2,
+    "LLAMA2": LLAMA,
     "LEO": LEO,
     "KOBOLDAI": KOBOLDAI,
     "OPENGPT": OPENGPT,
@@ -124,7 +123,7 @@ class AUTO(Provider):
         self.provider: Union[
             ThinkAnyAI,
             Xjai,
-            LLAMA2,
+            LLAMA,
             LEO,
             KOBOLDAI,
             OPENGPT,
@@ -353,13 +352,12 @@ class AsyncAUTO(AsyncProvider):
             AsyncOPENGPT,
             AsyncKOBOLDAI,
             AsyncPhindSearch,
-            AsyncLLAMA2,
             AsyncBLACKBOXAI,
             AsyncGPT4FREE,
             AsyncLEO,
             ThinkAnyAI,
             Xjai,
-            LLAMA2,
+            LLAMA,
             LEO,
             KOBOLDAI,
             OPENGPT,

{webscout-4.3 → webscout-4.4}/webscout/Extra/autollama.py

@@ -1,6 +1,14 @@
 import subprocess
 import argparse
 import os
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import track
+from yaspin import yaspin
+from pyfiglet import figlet_format
+import time
+
+console = Console()
 
 def autollama(model_path, gguf_file):
     """Manages models with Ollama using the autollama.sh script.
@@ -9,6 +17,7 @@ def autollama(model_path, gguf_file):
         model_path (str): The path to the Hugging Face model.
         gguf_file (str): The name of the GGUF file. 
     """
+    console.print(f"[bold green]{figlet_format('Autollama')}[/]\n", justify="center")
 
     # Check if autollama.sh exists in the current working directory
     script_path = os.path.join(os.getcwd(), "autollama.sh")
@@ -172,25 +181,27 @@ echo "Use Ollama run $MODEL_NAME"
     # 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='')
+    for line in iter(process.stdout.readline, ''): 
+        console.print(Panel(line.strip(), title="Autollama Output", expand=False)) 
 
+    for line in iter(process.stderr.readline, ''): 
+        console.print(Panel(line.strip(), title="Autollama Errors (if any)", expand=False))
+    
     process.wait()
+    console.print("[green]Model is ready![/]")
 
 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('-m', '--model_path', required=True, help='Set the huggingface 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)
+        with yaspin(text="Processing...") as spinner:
+            autollama(args.model_path, args.gguf_file)
+        spinner.ok("Done!")
     except Exception as e:
-        print(f"Error: {e}")
+        console.print(f"[red]Error: {e}[/]")
         exit(1)
 
 if __name__ == "__main__":

{webscout-4.3 → webscout-4.4}/webscout/Extra/gguf.py

@@ -1,7 +1,10 @@
 # webscout/Extra/gguf.py
 import subprocess
-import argparse
 import os 
+from pyfiglet import figlet_format
+from rich.console import Console
+
+console = Console()
 
 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.
@@ -17,6 +20,7 @@ def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5
         ValueError: If an invalid quantization method is provided.
     """
 
+    console.print(f"[bold green]{figlet_format('GGUF Converter')}[/]\n", justify="center")
     # List of valid quantization methods
     valid_methods = [
         "q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
@@ -220,21 +224,3 @@ echo "Script completed."
     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-4.4/webscout/Extra/weather.py

@@ -0,0 +1,67 @@
+import requests
+from rich.console import Console
+from rich.table import Table
+from yaspin import yaspin
+from pyfiglet import figlet_format
+
+console = Console()
+
+def get(location):
+    """Fetches weather data for the given location.
+
+    Args:
+        location (str): The location for which to fetch weather data.
+
+    Returns:
+        dict: A dictionary containing weather data if the request is successful,
+              otherwise a string indicating the error.
+    """
+    url = f"https://wttr.in/{location}?format=j1"
+    
+    with yaspin(text="Fetching weather data...") as spinner:
+        response = requests.get(url)
+        spinner.ok("✅ ")
+
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return f"Error: Unable to fetch weather data. Status code: {response.status_code}"
+
+def print_weather(weather_data):
+    """Prints the weather data in a user-friendly format.
+
+    Args:
+        weather_data (dict or str): The weather data returned from get_weather() 
+                                  or an error message.
+    """
+    if isinstance(weather_data, str):
+        console.print(f"[bold red]Error:[/] {weather_data}")
+        return
+
+    current = weather_data['current_condition'][0]
+    location_name = weather_data['nearest_area'][0]['areaName'][0]['value']
+
+    console.print(f"[bold blue]\n{figlet_format('Weather Report')}[/]\n", justify="center")
+    console.print(f"[bold green]Weather in {location_name}:[/]\n")
+
+    table = Table(show_header=False, show_lines=True)
+    table.add_row("Temperature:", f"{current['temp_C']}°C / {current['temp_F']}°F")
+    table.add_row("Condition:", current['weatherDesc'][0]['value'])
+    table.add_row("Humidity:", f"{current['humidity']}%")
+    table.add_row("Wind:", f"{current['windspeedKmph']} km/h, {current['winddir16Point']}")
+    console.print(table)
+
+    console.print(f"\n[bold green]Forecast:[/]")
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Date", style="dim", width=12)
+    table.add_column("Temperature Range")
+    table.add_column("Description")
+    
+    for day in weather_data['weather']:
+        date = day['date']
+        max_temp = day['maxtempC']
+        min_temp = day['mintempC']
+        desc = day['hourly'][4]['weatherDesc'][0]['value'] 
+        table.add_row(date, f"{min_temp}°C to {max_temp}°C", desc)
+    console.print(table)
+

{webscout-4.3 → webscout-4.4}/webscout/Extra/weather_ascii.py

@@ -1,5 +1,8 @@
 import requests
+from rich.console import Console
+from pyfiglet import figlet_format
 
+console = Console()
 def get(location):
     """Fetches ASCII art weather data for the given location.
     Args:
@@ -9,6 +12,7 @@ def get(location):
         str: ASCII art weather report if the request is successful,
              otherwise an error message.
     """
+    console.print(f"[bold green]{figlet_format('Weather')}[/]\n", justify="center")
     url = f"https://wttr.in/{location}"
     response = requests.get(url, headers={'User-Agent': 'curl'}) 
 
@@ -16,3 +20,4 @@ def get(location):
         return "\n".join(response.text.splitlines()[:-1]) 
     else:
         return f"Error: Unable to fetch weather data. Status code: {response.status_code}"
+

webscout-4.4/webscout/GoogleS.py

@@ -0,0 +1,342 @@
+import os
+import random
+import sys
+import time
+import ssl
+
+if sys.version_info[0] > 2:
+    from http.cookiejar import LWPCookieJar
+    from urllib.request import Request, urlopen
+    from urllib.parse import quote_plus, urlparse, parse_qs
+else:
+    from cookielib import LWPCookieJar
+    from urllib import quote_plus
+    from urllib2 import Request, urlopen
+    from urlparse import urlparse, parse_qs
+
+try:
+    from bs4 import BeautifulSoup
+    is_bs4 = True
+except ImportError:
+    from BeautifulSoup import BeautifulSoup  # type: ignore
+    is_bs4 = False
+
+__all__ = [
+
+    # Main search function.
+    'search',
+
+    # Shortcut for "get lucky" search.
+    'lucky',
+
+    # Miscellaneous utility functions.
+    'get_random_user_agent', 'get_tbs',
+]
+
+# URL templates to make Google searches.
+url_home = "https://www.google.%(tld)s/"
+url_search = "https://www.google.%(tld)s/search?hl=%(lang)s&q=%(query)s&" \
+             "btnG=Google+Search&tbs=%(tbs)s&safe=%(safe)s&" \
+             "cr=%(country)s"
+url_next_page = "https://www.google.%(tld)s/search?hl=%(lang)s&q=%(query)s&" \
+                "start=%(start)d&tbs=%(tbs)s&safe=%(safe)s&" \
+                "cr=%(country)s"
+url_search_num = "https://www.google.%(tld)s/search?hl=%(lang)s&q=%(query)s&" \
+                 "num=%(num)d&btnG=Google+Search&tbs=%(tbs)s&safe=%(safe)s&" \
+                 "cr=%(country)s"
+url_next_page_num = "https://www.google.%(tld)s/search?hl=%(lang)s&" \
+                    "q=%(query)s&num=%(num)d&start=%(start)d&tbs=%(tbs)s&" \
+                    "safe=%(safe)s&cr=%(country)s"
+url_parameters = (
+    'hl', 'q', 'num', 'btnG', 'start', 'tbs', 'safe', 'cr')
+
+# Cookie jar. Stored at the user's home folder.
+# If the cookie jar is inaccessible, the errors are ignored.
+home_folder = os.getenv('HOME')
+if not home_folder:
+    home_folder = os.getenv('USERHOME')
+    if not home_folder:
+        home_folder = '.'   # Use the current folder on error.
+cookie_jar = LWPCookieJar(os.path.join(home_folder, '.google-cookie'))
+try:
+    cookie_jar.load()
+except Exception:
+    pass
+
+# Default user agent, unless instructed by the user to change it.
+USER_AGENT = 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0)'
+
+try:
+    install_folder = os.path.abspath(os.path.split(__file__)[0])
+    try:
+        user_agents_file = os.path.join(install_folder, 'user_agents.txt.gz')
+        import gzip
+        fp = gzip.open(user_agents_file, 'rb')
+        try:
+            user_agents_list = [_.strip() for _ in fp.readlines()]
+        finally:
+            fp.close()
+            del fp
+    except Exception:
+        user_agents_file = os.path.join(install_folder, 'user_agents.txt')
+        with open(user_agents_file) as fp:
+            user_agents_list = [_.strip() for _ in fp.readlines()]
+except Exception:
+    user_agents_list = [USER_AGENT]
+
+
+# Get a random user agent.
+def get_random_user_agent():
+    """
+    Get a random user agent string.
+
+    :rtype: str
+    :return: Random user agent string.
+    """
+    return random.choice(user_agents_list)
+
+
+# Helper function to format the tbs parameter.
+def get_tbs(from_date, to_date):
+    """
+    Helper function to format the tbs parameter.
+
+    :param datetime.date from_date: Python date object.
+    :param datetime.date to_date: Python date object.
+
+    :rtype: str
+    :return: Dates encoded in tbs format.
+    """
+    from_date = from_date.strftime('%m/%d/%Y')
+    to_date = to_date.strftime('%m/%d/%Y')
+    return 'cdr:1,cd_min:%(from_date)s,cd_max:%(to_date)s' % vars()
+
+
+# Request the given URL and return the response page, using the cookie jar.
+# If the cookie jar is inaccessible, the errors are ignored.
+def get_page(url, user_agent=None, verify_ssl=True):
+    """
+    Request the given URL and return the response page, using the cookie jar.
+
+    :param str url: URL to retrieve.
+    :param str user_agent: User agent for the HTTP requests.
+        Use None for the default.
+    :param bool verify_ssl: Verify the SSL certificate to prevent
+        traffic interception attacks. Defaults to True.
+
+    :rtype: str
+    :return: Web page retrieved for the given URL.
+
+    :raises IOError: An exception is raised on error.
+    :raises urllib2.URLError: An exception is raised on error.
+    :raises urllib2.HTTPError: An exception is raised on error.
+    """
+    if user_agent is None:
+        user_agent = USER_AGENT
+    request = Request(url)
+    request.add_header('User-Agent', user_agent)
+    cookie_jar.add_cookie_header(request)
+    if verify_ssl:
+        response = urlopen(request)
+    else:
+        context = ssl._create_unverified_context()
+        response = urlopen(request, context=context)
+    cookie_jar.extract_cookies(response, request)
+    html = response.read()
+    response.close()
+    try:
+        cookie_jar.save()
+    except Exception:
+        pass
+    return html
+
+
+# Filter links found in the Google result pages HTML code.
+# Returns None if the link doesn't yield a valid result.
+def filter_result(link):
+    try:
+
+        # Decode hidden URLs.
+        if link.startswith('/url?'):
+            o = urlparse(link, 'http')
+            link = parse_qs(o.query)['q'][0]
+
+        # Valid results are absolute URLs not pointing to a Google domain,
+        # like images.google.com or googleusercontent.com for example.
+        # TODO this could be improved!
+        o = urlparse(link, 'http')
+        if o.netloc and 'google' not in o.netloc:
+            return link
+
+    # On error, return None.
+    except Exception:
+        pass
+
+
+# Returns a generator that yields URLs.
+def search(query, tld='com', lang='en', tbs='0', safe='off', num=10, start=0,
+           stop=None, pause=2.0, country='', extra_params=None,
+           user_agent=None, verify_ssl=True):
+    """
+    Search the given query string using Google.
+
+    :param str query: Query string. Must NOT be url-encoded.
+    :param str tld: Top level domain.
+    :param str lang: Language.
+    :param str tbs: Time limits (i.e "qdr:h" => last hour,
+        "qdr:d" => last 24 hours, "qdr:m" => last month).
+    :param str safe: Safe search.
+    :param int num: Number of results per page.
+    :param int start: First result to retrieve.
+    :param int stop: Last result to retrieve.
+        Use None to keep searching forever.
+    :param float pause: Lapse to wait between HTTP requests.
+        A lapse too long will make the search slow, but a lapse too short may
+        cause Google to block your IP. Your mileage may vary!
+    :param str country: Country or region to focus the search on. Similar to
+        changing the TLD, but does not yield exactly the same results.
+        Only Google knows why...
+    :param dict extra_params: A dictionary of extra HTTP GET
+        parameters, which must be URL encoded. For example if you don't want
+        Google to filter similar results you can set the extra_params to
+        {'filter': '0'} which will append '&filter=0' to every query.
+    :param str user_agent: User agent for the HTTP requests.
+        Use None for the default.
+    :param bool verify_ssl: Verify the SSL certificate to prevent
+        traffic interception attacks. Defaults to True.
+
+    :rtype: generator of str
+    :return: Generator (iterator) that yields found URLs.
+        If the stop parameter is None the iterator will loop forever.
+    """
+    # Set of hashes for the results found.
+    # This is used to avoid repeated results.
+    hashes = set()
+
+    # Count the number of links yielded.
+    count = 0
+
+    # Prepare the search string.
+    query = quote_plus(query)
+
+    # If no extra_params is given, create an empty dictionary.
+    # We should avoid using an empty dictionary as a default value
+    # in a function parameter in Python.
+    if not extra_params:
+        extra_params = {}
+
+    # Check extra_params for overlapping.
+    for builtin_param in url_parameters:
+        if builtin_param in extra_params.keys():
+            raise ValueError(
+                'GET parameter "%s" is overlapping with \
+                the built-in GET parameter',
+                builtin_param
+            )
+
+    # Grab the cookie from the home page.
+    get_page(url_home % vars(), user_agent, verify_ssl)
+
+    # Prepare the URL of the first request.
+    if start:
+        if num == 10:
+            url = url_next_page % vars()
+        else:
+            url = url_next_page_num % vars()
+    else:
+        if num == 10:
+            url = url_search % vars()
+        else:
+            url = url_search_num % vars()
+
+    # Loop until we reach the maximum result, if any (otherwise, loop forever).
+    while not stop or count < stop:
+
+        # Remeber last count to detect the end of results.
+        last_count = count
+
+        # Append extra GET parameters to the URL.
+        # This is done on every iteration because we're
+        # rebuilding the entire URL at the end of this loop.
+        for k, v in extra_params.items():
+            k = quote_plus(k)
+            v = quote_plus(v)
+            url = url + ('&%s=%s' % (k, v))
+
+        # Sleep between requests.
+        # Keeps Google from banning you for making too many requests.
+        time.sleep(pause)
+
+        # Request the Google Search results page.
+        html = get_page(url, user_agent, verify_ssl)
+
+        # Parse the response and get every anchored URL.
+        if is_bs4:
+            soup = BeautifulSoup(html, 'html.parser')
+        else:
+            soup = BeautifulSoup(html)
+        try:
+            anchors = soup.find(id='search').findAll('a')
+            # Sometimes (depending on the User-agent) there is
+            # no id "search" in html response...
+        except AttributeError:
+            # Remove links of the top bar.
+            gbar = soup.find(id='gbar')
+            if gbar:
+                gbar.clear()
+            anchors = soup.findAll('a')
+
+        # Process every anchored URL.
+        for a in anchors:
+
+            # Get the URL from the anchor tag.
+            try:
+                link = a['href']
+            except KeyError:
+                continue
+
+            # Filter invalid links and links pointing to Google itself.
+            link = filter_result(link)
+            if not link:
+                continue
+
+            # Discard repeated results.
+            h = hash(link)
+            if h in hashes:
+                continue
+            hashes.add(h)
+
+            # Yield the result.
+            yield link
+
+            # Increase the results counter.
+            # If we reached the limit, stop.
+            count += 1
+            if stop and count >= stop:
+                return
+
+        # End if there are no more results.
+        # XXX TODO review this logic, not sure if this is still true!
+        if last_count == count:
+            break
+
+        # Prepare the URL for the next request.
+        start += num
+        if num == 10:
+            url = url_next_page % vars()
+        else:
+            url = url_next_page_num % vars()
+
+
+# Shortcut to single-item search.
+# Evaluates the iterator to return the single URL as a string.
+def lucky(*args, **kwargs):
+    """
+    Shortcut to single-item search.
+
+    Same arguments as the main search function, but the return value changes.
+
+    :rtype: str
+    :return: URL found by Google.
+    """
+    return next(search(*args, **kwargs))

{webscout-4.3 → webscout-4.4}/webscout/__init__.py

@@ -5,16 +5,16 @@ from .DWEBS import *
 from .transcriber import transcriber
 from .voice import play_audio
 from .websx_search import WEBSX
-
 from .LLM import VLM, LLM
 from .YTdownloader import *
-# from .Local import *
+from .GoogleS import *
 import g4f
 from .YTdownloader import *
 from .Provider import *
 from .Extra import gguf
 from .Extra import autollama
 from .Extra import weather_ascii, weather
+
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 
 webai = [
@@ -58,12 +58,15 @@ __all__ = [
    "WEBS",
    "AsyncWEBS",
    "__version__",
-   "DeepWEBS",
+   "DWEBS",
    "transcriber",
    "play_audio",
    "TempMailClient", 
    "TemporaryPhoneNumber",
    "LLM",
+   "YTdownloader",
+   "WEBSX",
+   "VLM",
    # Localai models and utilities 
    # "Model",
    # "Thread",