webscout 4.2__py3-none-any.whl → 4.4__py3-none-any.whl

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.Llama2 import LLAMA2
-from webscout.Provider.Llama2 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/AIutel.py

@@ -220,17 +220,16 @@ class Conversation:
         ), f"File '{filepath}' does not exist"
         if not os.path.isfile(filepath):
             logging.debug(f"Creating new chat-history file - '{filepath}'")
-            with open(filepath, "w") as fh:  # Try creating new file
-                # lets add intro here
+            with open(filepath, "w", encoding="utf-8") as fh:  # Try creating new file with UTF-8 encoding
                 fh.write(self.intro)
         else:
             logging.debug(f"Loading conversation from '{filepath}'")
-            with open(filepath) as fh:
+            with open(filepath, encoding="utf-8") as fh:  # Open with UTF-8 encoding
                 file_contents = fh.readlines()
                 if file_contents:
                     self.intro = file_contents[0]  # Presume first line is the intro.
                     self.chat_history = "\n".join(file_contents[1:])
-
+    
     def __trim_chat_history(self, chat_history: str, intro: str) -> str:
         """Ensures the len(prompt) and max_tokens_to_sample is not > 4096"""
         len_of_intro = len(intro)
@@ -243,7 +242,6 @@ class Conversation:
             # Remove head of total (n) of chat_history
             trimmed_chat_history = chat_history[truncate_at:]
             return "... " + trimmed_chat_history
-            # print(len(self.chat_history))
         else:
             return chat_history
 
@@ -281,12 +279,12 @@ class Conversation:
         new_history = self.history_format % dict(user=prompt, llm=response)
         if self.file and self.update_file:
             if os.path.exists(self.file):
-                with open(self.file, "w") as fh:
+                with open(self.file, "w", encoding="utf-8") as fh:  # Specify UTF-8 encoding
                     fh.write(self.intro + "\n" + new_history)
             else:
-                with open(self.file, "a") as fh:
+                with open(self.file, "a", encoding="utf-8") as fh:  # Specify UTF-8 encoding
                     fh.write(new_history)
-        self.chat_history += new_history
+            self.chat_history += new_history
 
 
 

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/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/Extra/weather.py

@@ -1,4 +1,10 @@
 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.
@@ -12,7 +18,9 @@ def get(location):
     """
     url = f"https://wttr.in/{location}?format=j1"
     
-    response = requests.get(url)
+    with yaspin(text="Fetching weather data...") as spinner:
+        response = requests.get(url)
+        spinner.ok("✅ ")
 
     if response.status_code == 200:
         return response.json()
@@ -27,23 +35,33 @@ def print_weather(weather_data):
                                   or an error message.
     """
     if isinstance(weather_data, str):
-        print(weather_data)
+        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']
 
-    print(f"Weather in {location_name}:")
-    print(f"Temperature: {current['temp_C']}°C / {current['temp_F']}°F")
-    print(f"Condition: {current['weatherDesc'][0]['value']}")
-    print(f"Humidity: {current['humidity']}%")
-    print(f"Wind: {current['windspeedKmph']} km/h, {current['winddir16Point']}")
+    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)
 
-    print("\nForecast:")
+    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'] 
-        print(f"{date}: {min_temp}°C to {max_temp}°C, {desc}")
+        table.add_row(date, f"{min_temp}°C to {max_temp}°C", desc)
+    console.print(table)
+

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/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/Local/_version.py

@@ -1,3 +1,3 @@
 from llama_cpp import __version__ as __llama_cpp_version__
 
-__version__ = '4.2'
+__version__ = '4.3'