webscout 3.1b0__tar.gz → 3.3__tar.gz

webscout-3.3/LICENSE.md

@@ -0,0 +1,50 @@
+************************************************
+**** HelpingAI License ****
+************************************************
+
+Version 2.0
+
+Developed by Abhay Koul
+
+### Preamble
+
+The HelpingAI License governs the use of HelpingAI's digital assets, including but not limited to software, scripts, datasets, documents, images, audio recordings, videos. The HelpingAI License aims to provide clear, comprehensive terms for accessing, modifying, and sharing resources, while promoting ethical development practices.
+
+### Grant of Rights
+
+Under the HelpingAI License, HelpingAI grants you the rights to copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Content, provided you comply with the terms and conditions outlined in this document.
+
+### Terms and Conditions
+
+To exercise the rights granted in the previous section, you must adhere to the following terms and conditions:
+
+2.1. **Redistribution of Source Code.**
+ If you redistribute the Source Code, you must include the complete HelpingAI License with your distribution. You must also add clear notifications in all modified files stating:
+
+ > "This Work is released under the HelpingAI License v2.0."
+
+2.2. **Distribution in Binary Form.**
+ If you distribute Binaries derived from the Source Code, you must include the following statement in your distribution:
+
+ > "This Work is based on the HelpingAI Licensed Work, under the HelpingAI License v2.0."
+
+2.3. **Notification of Changes.**
+ You must clearly indicate any modifications you make to the Source Code or Documentation, including detailed comments about the nature and extent of the changes. Include the date and originator of the modifications.
+
+2.4. **Branding Attribution.**
+ You must not remove or alter any HelpingAI branding, logos, or notices included in the Content without explicit prior consent from HelpingAI.
+
+2.5. **Disclaimer of Warranty.**
+ The Content is provided "AS IS," without any implied warranties, including but not limited to warranties of merchantability, fitness for a particular purpose, and non-infringement.
+
+2.6. **Limitation of Liability.**
+ To the maximum extent permitted by law, neither HelpingAI nor any contributor shall be liable for any loss, personal injury, property damage, or any indirect, special, incidental, or consequential damages arising from or related to the use of the Content.
+
+2.7. **Governing Law.**
+ This HelpingAI License shall be governed and construed in accordance with the laws of the jurisdiction where HelpingAI primarily operates.
+
+### Definitions
+
+3.1. **"Source Code"** refers to the preferred form for making modifications to the Content, typically represented by human-readable programming languages, scripts, or documentation formats.
+
+3.2. **"Binaries"** refers to compiled forms of the Source Code, such as executables, libraries, or similar artifacts produced from the Source Code.

{webscout-3.1b0 → webscout-3.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.1b0
+Version: 3.3
 Summary: Search for anything using Google, DuckDuckGo, 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
 Author: OEvortex
 Author-email: helpingai5@gmail.com
-License: HelpingAI Simplified Universal License
+License: HelpingAI
 Project-URL: Documentation, https://github.com/OE-LUCIFER/Webscout/wiki
 Project-URL: Source, https://github.com/OE-LUCIFER/Webscout
 Project-URL: Tracker, https://github.com/OE-LUCIFER/Webscout/issues
@@ -140,9 +140,11 @@ Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can
     - [14. `chatgptuk` - Chat with gemini-pro](#14-chatgptuk---chat-with-gemini-pro)
     - [15. `poe`- chat with poe](#15-poe--chat-with-poe)
     - [16. `BasedGPT` - chat with GPT](#16-basedgpt---chat-with-gpt)
+    - [17. `DeepSeek` -chat with deepseek](#17-deepseek--chat-with-deepseek)
     - [`LLM`](#llm)
     - [`Local-LLM` webscout can now run GGUF models](#local-llm-webscout-can-now-run-gguf-models)
     - [`Function-calling-local-llm`](#function-calling-local-llm)
+    - [`Local-rawdog`](#local-rawdog)
     - [`LLM` with internet](#llm-with-internet)
     - [LLM with deepwebs](#llm-with-deepwebs)
   - [`Webai` - terminal gpt and a open interpeter](#webai---terminal-gpt-and-a-open-interpeter)
@@ -1218,6 +1220,39 @@ Usage code similar to other proviers
 
 ### 16. `BasedGPT` - chat with GPT
 Usage code similar to other providers
+
+### 17. `DeepSeek` -chat with deepseek
+```python
+from webscout import DeepSeek
+from rich import print
+
+ai = DeepSeek(
+    is_conversation=True,
+    api_key='', # Watch this video https://youtu.be/Euin6p5Ryks?si=-84JBtyqGwMzvdIq to know from where u can get this key for free 
+    max_tokens=800,
+    timeout=30,
+    intro=None,
+    filepath=None,
+    update_file=True,
+    proxies={},
+    history_offset=10250,
+    act=None,
+    model="deepseek_chat"
+)
+
+# Start an infinite loop for continuous interaction
+while True:
+    # Define a prompt to send to the AI
+    prompt = input("Enter your prompt: ")
+    
+    # Check if the user wants to exit the loop
+    if prompt.lower() == "exit":
+        break
+    
+    # Use the 'chat' method to send the prompt and receive a response
+    r = ai.chat(prompt)
+    print(r)
+```
 ### `LLM` 
 ```python
 from webscout.LLM import LLM
@@ -1245,6 +1280,7 @@ while True:
     print("AI: ", response)
 ```
 ### `Local-LLM` webscout can now run GGUF models
+Local LLM's some functions are taken from easy-llama
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
@@ -1336,6 +1372,93 @@ while True:
     response = thread.send(user_input)
     print("Bot: ", response) 
 ```
+### `Local-rawdog`
+```python
+import webscout.Local as ws
+from webscout.Local.rawdog import RawDog
+from webscout.Local.samplers import DefaultSampling
+from webscout.Local.formats import chatml, AdvancedFormat
+from webscout.Local.utils import download_model
+import datetime
+import sys
+import os
+
+repo_id = "YorkieOH10/granite-8b-code-instruct-Q8_0-GGUF" 
+filename = "granite-8b-code-instruct.Q8_0.gguf"
+model_path = download_model(repo_id, filename, token='')
+
+# Load the model using the downloaded path
+model = ws.Model(model_path, n_gpu_layers=10)
+
+rawdog = RawDog()
+
+# Create an AdvancedFormat and modify the system content
+# Use a lambda to generate the prompt dynamically:
+chat_format = AdvancedFormat(chatml)
+#  **Pre-format the intro_prompt string:**
+system_content = f"""
+You are a command-line coding assistant called Rawdog that generates and auto-executes Python scripts.
+
+A typical interaction goes like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+3. The compiler extracts the script and then runs it using exec(). If there will be an exception raised,
+ it will be send back to you starting with "PREVIOUS SCRIPT EXCEPTION:".
+4. In case of exception, regenerate error free script.
+
+If you need to review script outputs before completing the task, you can print the word "CONTINUE" at the end of your SCRIPT.
+This can be useful for summarizing documents or technical readouts, reading instructions before
+deciding what to do, or other tasks that require multi-step reasoning.
+A typical 'CONTINUE' interaction looks like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Determine that you need to see the output of some subprocess call to complete the task
+    iii. Write a short Python SCRIPT to print that and then print the word "CONTINUE"
+3. The compiler
+    i. Checks and runs your SCRIPT
+    ii. Captures the output and appends it to the conversation as "LAST SCRIPT OUTPUT:"
+    iii. Finds the word "CONTINUE" and sends control back to you
+4. You again:
+    i. Look at the original PROMPT + the "LAST SCRIPT OUTPUT:" to determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+5. The compiler...
+
+Please follow these conventions carefully:
+- Decline any tasks that seem dangerous, irreversible, or that you don't understand.
+- Always review the full conversation prior to answering and maintain continuity.
+- If asked for information, just print the information clearly and concisely.
+- If asked to do something, print a concise summary of what you've done as confirmation.
+- If asked a question, respond in a friendly, conversational way. Use programmatically-generated and natural language responses as appropriate.
+- If you need clarification, return a SCRIPT that prints your question. In the next interaction, continue based on the user's response.
+- Assume the user would like something concise. For example rather than printing a massive table, filter or summarize it to what's likely of interest.
+- Actively clean up any temporary processes or files you use.
+- When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
+- You can plot anything with matplotlib.
+- ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. Only the console output of the first such SCRIPT is visible to the user, so make sure that it's complete and don't bother returning anything else.
+"""
+chat_format.override('system_content', lambda: system_content)
+
+thread = ws.Thread(model, format=chat_format, sampler=DefaultSampling)
+
+while True:
+    prompt = input(">: ")
+    if prompt.lower() == "q":
+        break
+
+    response = thread.send(prompt)
+
+    # Process the response using RawDog
+    script_output = rawdog.main(response)
+
+    if script_output:
+        print(script_output)
+
+```
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.1b0 → webscout-3.3}/README.md

@@ -75,9 +75,11 @@ Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can
     - [14. `chatgptuk` - Chat with gemini-pro](#14-chatgptuk---chat-with-gemini-pro)
     - [15. `poe`- chat with poe](#15-poe--chat-with-poe)
     - [16. `BasedGPT` - chat with GPT](#16-basedgpt---chat-with-gpt)
+    - [17. `DeepSeek` -chat with deepseek](#17-deepseek--chat-with-deepseek)
     - [`LLM`](#llm)
     - [`Local-LLM` webscout can now run GGUF models](#local-llm-webscout-can-now-run-gguf-models)
     - [`Function-calling-local-llm`](#function-calling-local-llm)
+    - [`Local-rawdog`](#local-rawdog)
     - [`LLM` with internet](#llm-with-internet)
     - [LLM with deepwebs](#llm-with-deepwebs)
   - [`Webai` - terminal gpt and a open interpeter](#webai---terminal-gpt-and-a-open-interpeter)
@@ -1153,6 +1155,39 @@ Usage code similar to other proviers
 
 ### 16. `BasedGPT` - chat with GPT
 Usage code similar to other providers
+
+### 17. `DeepSeek` -chat with deepseek
+```python
+from webscout import DeepSeek
+from rich import print
+
+ai = DeepSeek(
+    is_conversation=True,
+    api_key='', # Watch this video https://youtu.be/Euin6p5Ryks?si=-84JBtyqGwMzvdIq to know from where u can get this key for free 
+    max_tokens=800,
+    timeout=30,
+    intro=None,
+    filepath=None,
+    update_file=True,
+    proxies={},
+    history_offset=10250,
+    act=None,
+    model="deepseek_chat"
+)
+
+# Start an infinite loop for continuous interaction
+while True:
+    # Define a prompt to send to the AI
+    prompt = input("Enter your prompt: ")
+    
+    # Check if the user wants to exit the loop
+    if prompt.lower() == "exit":
+        break
+    
+    # Use the 'chat' method to send the prompt and receive a response
+    r = ai.chat(prompt)
+    print(r)
+```
 ### `LLM` 
 ```python
 from webscout.LLM import LLM
@@ -1180,6 +1215,7 @@ while True:
     print("AI: ", response)
 ```
 ### `Local-LLM` webscout can now run GGUF models
+Local LLM's some functions are taken from easy-llama
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
@@ -1271,6 +1307,93 @@ while True:
     response = thread.send(user_input)
     print("Bot: ", response) 
 ```
+### `Local-rawdog`
+```python
+import webscout.Local as ws
+from webscout.Local.rawdog import RawDog
+from webscout.Local.samplers import DefaultSampling
+from webscout.Local.formats import chatml, AdvancedFormat
+from webscout.Local.utils import download_model
+import datetime
+import sys
+import os
+
+repo_id = "YorkieOH10/granite-8b-code-instruct-Q8_0-GGUF" 
+filename = "granite-8b-code-instruct.Q8_0.gguf"
+model_path = download_model(repo_id, filename, token='')
+
+# Load the model using the downloaded path
+model = ws.Model(model_path, n_gpu_layers=10)
+
+rawdog = RawDog()
+
+# Create an AdvancedFormat and modify the system content
+# Use a lambda to generate the prompt dynamically:
+chat_format = AdvancedFormat(chatml)
+#  **Pre-format the intro_prompt string:**
+system_content = f"""
+You are a command-line coding assistant called Rawdog that generates and auto-executes Python scripts.
+
+A typical interaction goes like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+3. The compiler extracts the script and then runs it using exec(). If there will be an exception raised,
+ it will be send back to you starting with "PREVIOUS SCRIPT EXCEPTION:".
+4. In case of exception, regenerate error free script.
+
+If you need to review script outputs before completing the task, you can print the word "CONTINUE" at the end of your SCRIPT.
+This can be useful for summarizing documents or technical readouts, reading instructions before
+deciding what to do, or other tasks that require multi-step reasoning.
+A typical 'CONTINUE' interaction looks like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Determine that you need to see the output of some subprocess call to complete the task
+    iii. Write a short Python SCRIPT to print that and then print the word "CONTINUE"
+3. The compiler
+    i. Checks and runs your SCRIPT
+    ii. Captures the output and appends it to the conversation as "LAST SCRIPT OUTPUT:"
+    iii. Finds the word "CONTINUE" and sends control back to you
+4. You again:
+    i. Look at the original PROMPT + the "LAST SCRIPT OUTPUT:" to determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+5. The compiler...
+
+Please follow these conventions carefully:
+- Decline any tasks that seem dangerous, irreversible, or that you don't understand.
+- Always review the full conversation prior to answering and maintain continuity.
+- If asked for information, just print the information clearly and concisely.
+- If asked to do something, print a concise summary of what you've done as confirmation.
+- If asked a question, respond in a friendly, conversational way. Use programmatically-generated and natural language responses as appropriate.
+- If you need clarification, return a SCRIPT that prints your question. In the next interaction, continue based on the user's response.
+- Assume the user would like something concise. For example rather than printing a massive table, filter or summarize it to what's likely of interest.
+- Actively clean up any temporary processes or files you use.
+- When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
+- You can plot anything with matplotlib.
+- ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. Only the console output of the first such SCRIPT is visible to the user, so make sure that it's complete and don't bother returning anything else.
+"""
+chat_format.override('system_content', lambda: system_content)
+
+thread = ws.Thread(model, format=chat_format, sampler=DefaultSampling)
+
+while True:
+    prompt = input(">: ")
+    if prompt.lower() == "q":
+        break
+
+    response = thread.send(prompt)
+
+    # Process the response using RawDog
+    script_output = rawdog.main(response)
+
+    if script_output:
+        print(script_output)
+
+```
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.1b0 → webscout-3.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="3.1-beta",
+    version="3.3",
     description="Search for anything using Google, DuckDuckGo, 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",
     long_description=README,
     long_description_content_type="text/markdown",
@@ -77,7 +77,7 @@ setup(
             'huggingface_hub',
         ],
     },
-    license="HelpingAI Simplified Universal License",
+    license="HelpingAI",
     project_urls={
         "Documentation": "https://github.com/OE-LUCIFER/Webscout/wiki",
         "Source": "https://github.com/OE-LUCIFER/Webscout",

{webscout-3.1b0 → webscout-3.3}/webscout/AIutel.py

@@ -47,6 +47,7 @@ webai = [
    "auto",
    "poe",
    "basedgpt",
+   "deepseek",
 ]
 gpt4free_providers = [
     provider.__name__ for provider in g4f.Provider.__providers__  # if provider.working
@@ -213,12 +214,12 @@ 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
+            with open(filepath, "w", encoding='utf-8') as fh:  # Try creating new file
                 # lets add intro here
                 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:
                 file_contents = fh.read()
                 # Presume intro prompt is part of the file content
                 self.chat_history = file_contents
@@ -269,7 +270,7 @@ class Conversation:
             return
         new_history = self.history_format % dict(user=prompt, llm=response)
         if self.file and self.update_file:
-            with open(self.file, "a") as fh:
+            with open(self.file, "a", encoding='utf-8') as fh:
                 fh.write(new_history)
         self.chat_history += new_history
 
@@ -540,6 +541,7 @@ print("The essay is about...")
         """
         if not quiet:
             print(
+                "Rawdog is an experimental tool that generates and auto-executes Python scripts in the cli.\n"
                 "To get the most out of Rawdog. Ensure the following are installed:\n"
                 " 1. Python 3.x\n"
                 " 2. Dependency:\n"

{webscout-3.1b0 → webscout-3.3}/webscout/Local/__init__.py

@@ -8,3 +8,4 @@ from . import utils
 
 from .model  import Model
 from .thread import Thread
+from .rawdog import *

{webscout-3.1b0 → webscout-3.3}/webscout/Local/_version.py

@@ -1,3 +1,3 @@
 from llama_cpp import __version__ as __llama_cpp_version__
 
-__version__ = '2.9'
+__version__ = '3.1'

{webscout-3.1b0 → webscout-3.3}/webscout/Local/rawdog.py

@@ -21,18 +21,16 @@ import logging
 import appdirs
 import datetime
 import re
-from .model import *
-from .utils import (
-    RESET_ALL,
-    _SupportsWriteAndFlush,
-    cls,
-    print_verbose,
-    truncate,
-    run_system_command
-)
+from .model    import Model, assert_model_is_loaded, _SupportsWriteAndFlush
+from .utils    import RESET_ALL, cls, print_verbose, truncate
 from .samplers import SamplerSettings, DefaultSampling
-from .formats import AdvancedFormat
+from typing    import Optional, Literal, Union
+from .formats  import AdvancedFormat
+
 from .formats import blank as formats_blank
+from ..AIutel import *
+from .samplers import SamplerSettings, DefaultSampling
+from .formats import AdvancedFormat
 from rich.markdown import Markdown
 from rich.console import Console
 appdir = appdirs.AppDirs("AIWEBS", "vortex")

webscout-3.3/webscout/Provider/Deepseek.py

@@ -0,0 +1,266 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict, Optional
+import logging
+import httpx
+import os
+from dotenv import load_dotenv; load_dotenv()
+
+#-----------------------------------------------DeepSeek--------------------------------------------
+class DeepSeek(Provider):
+    def __init__(
+        self,
+        api_key: str,
+        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,
+        model: str = 'deepseek_chat',
+        temperature: float = 1.0,
+    ):
+        """Initializes DeepSeek
+
+        Args:
+            api_key (str): DeepSeek API key.
+            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.
+            model_type (str, optional): DeepSeek model type. Defaults to 'deepseek_chat'.
+            temperature (float, optional): Creativity level of the response. Defaults to 1.0.
+        """
+        self.api_token = api_key
+        self.auth_headers = {
+            'Authorization': f'Bearer {self.api_token}'
+        }
+        self.api_base_url = 'https://chat.deepseek.com/api/v0/chat'
+        self.api_session = requests.Session()
+        self.api_session.headers.update(self.auth_headers)
+
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model_type = model
+        self.temperature = temperature
+        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 clear_chat(self) -> None:
+        """
+        Clears the chat context by making a POST request to the clear_context endpoint.
+        """
+        clear_payload = {"model_class": "deepseek_chat", "append_welcome_message": False}
+        clear_response = self.api_session.post(f'{self.api_base_url}/clear_context', json=clear_payload)
+        clear_response.raise_for_status()  # Raises an HTTPError if the HTTP request returned an unsuccessful status code
+
+    def generate(self, user_message: str, response_temperature: float = 1.0, model_type: Optional[str] = "deepseek_chat", verbose: bool = False) -> str:
+        """
+        Generates a response from the DeepSeek API based on the provided message.
+
+        Args:
+            user_message (str): The message to send to the chat API.
+            response_temperature (float, optional): The creativity level of the response. Defaults to 1.0.
+            model_type (str, optional): The model class to be used for the chat session.
+            verbose (bool, optional): Whether to print the response content. Defaults to False.
+
+        Returns:
+            str: The concatenated response content received from the API.
+
+        Available models:
+            - deepseek_chat
+            - deepseek_code
+        """
+        request_payload = {
+            "message": user_message,
+            "stream": True,
+            "model_preference": None,
+            "model_class": model_type,
+            "temperature": response_temperature
+        }
+        api_response = self.api_session.post(f'{self.api_base_url}/completions', json=request_payload, stream=True)
+        api_response.raise_for_status()
+
+        combined_response = ""
+        for response_line in api_response.iter_lines(decode_unicode=True, chunk_size=1):
+            if response_line:
+                cleaned_line = re.sub("data:", "", response_line)
+                response_json = json.loads(cleaned_line)
+                response_content = response_json['choices'][0]['delta']['content']
+                if response_content and not re.match(r'^\s{5,}$', response_content):
+                    if verbose: print(response_content, end="", flush=True)
+                    combined_response += response_content
+
+        return combined_response
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def for_stream():
+            response = self.generate(
+                user_message=conversation_prompt,
+                response_temperature=self.temperature,
+                model_type=self.model_type,
+                verbose=False,
+            )
+            # print(response)
+            self.last_response.update(dict(text=response))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            yield dict(text=response) if raw else dict(text=response)
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

{webscout-3.1b0 → webscout-3.3}/webscout/Provider/__init__.py

@@ -29,6 +29,7 @@ from .Berlin4h import Berlin4h
 from .ChatGPTUK import ChatGPTUK
 from .Poe import POE
 from .BasedGPT import BasedGPT
+from .Deepseek import DeepSeek
 __all__ = [
     'ThinkAnyAI',
     'Xjai',
@@ -59,4 +60,5 @@ __all__ = [
     'ChatGPTUK',
     'POE',
     'BasedGPT',
+    'DeepSeek',
 ]

{webscout-3.1b0 → webscout-3.3}/webscout/__init__.py

@@ -35,6 +35,7 @@ webai = [
    "auto",
    "poe",
    "basedgpt",
+   "deepseek",
 ]
 
 gpt4free_providers = [

webscout-3.3/webscout/version.py

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

{webscout-3.1b0 → webscout-3.3}/webscout/webai.py

@@ -625,7 +625,23 @@ class Main(cmd.Cmd):
                     model=getOr(model, "reka-core"),
                     # quiet=quiet,
                 )
+            elif provider == "deepseek":
+                from webscout import DeepSeek
 
+                self.bot = DeepSeek(
+                    api_key=auth,
+                    is_conversation=disable_conversation,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                    intro=intro,
+                    filepath=filepath,
+                    update_file=update_file,
+                    proxies=proxies,
+                    history_offset=history_offset,
+                    act=awesome_prompt,
+                    model=getOr(model, "deepseek_chat"),
+                    # quiet=quiet,
+                )
             elif provider == "koboldai":
                 from webscout import KOBOLDAI
 

{webscout-3.1b0 → webscout-3.3}/webscout.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.1b0
+Version: 3.3
 Summary: Search for anything using Google, DuckDuckGo, 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
 Author: OEvortex
 Author-email: helpingai5@gmail.com
-License: HelpingAI Simplified Universal License
+License: HelpingAI
 Project-URL: Documentation, https://github.com/OE-LUCIFER/Webscout/wiki
 Project-URL: Source, https://github.com/OE-LUCIFER/Webscout
 Project-URL: Tracker, https://github.com/OE-LUCIFER/Webscout/issues
@@ -140,9 +140,11 @@ Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can
     - [14. `chatgptuk` - Chat with gemini-pro](#14-chatgptuk---chat-with-gemini-pro)
     - [15. `poe`- chat with poe](#15-poe--chat-with-poe)
     - [16. `BasedGPT` - chat with GPT](#16-basedgpt---chat-with-gpt)
+    - [17. `DeepSeek` -chat with deepseek](#17-deepseek--chat-with-deepseek)
     - [`LLM`](#llm)
     - [`Local-LLM` webscout can now run GGUF models](#local-llm-webscout-can-now-run-gguf-models)
     - [`Function-calling-local-llm`](#function-calling-local-llm)
+    - [`Local-rawdog`](#local-rawdog)
     - [`LLM` with internet](#llm-with-internet)
     - [LLM with deepwebs](#llm-with-deepwebs)
   - [`Webai` - terminal gpt and a open interpeter](#webai---terminal-gpt-and-a-open-interpeter)
@@ -1218,6 +1220,39 @@ Usage code similar to other proviers
 
 ### 16. `BasedGPT` - chat with GPT
 Usage code similar to other providers
+
+### 17. `DeepSeek` -chat with deepseek
+```python
+from webscout import DeepSeek
+from rich import print
+
+ai = DeepSeek(
+    is_conversation=True,
+    api_key='', # Watch this video https://youtu.be/Euin6p5Ryks?si=-84JBtyqGwMzvdIq to know from where u can get this key for free 
+    max_tokens=800,
+    timeout=30,
+    intro=None,
+    filepath=None,
+    update_file=True,
+    proxies={},
+    history_offset=10250,
+    act=None,
+    model="deepseek_chat"
+)
+
+# Start an infinite loop for continuous interaction
+while True:
+    # Define a prompt to send to the AI
+    prompt = input("Enter your prompt: ")
+    
+    # Check if the user wants to exit the loop
+    if prompt.lower() == "exit":
+        break
+    
+    # Use the 'chat' method to send the prompt and receive a response
+    r = ai.chat(prompt)
+    print(r)
+```
 ### `LLM` 
 ```python
 from webscout.LLM import LLM
@@ -1245,6 +1280,7 @@ while True:
     print("AI: ", response)
 ```
 ### `Local-LLM` webscout can now run GGUF models
+Local LLM's some functions are taken from easy-llama
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
@@ -1336,6 +1372,93 @@ while True:
     response = thread.send(user_input)
     print("Bot: ", response) 
 ```
+### `Local-rawdog`
+```python
+import webscout.Local as ws
+from webscout.Local.rawdog import RawDog
+from webscout.Local.samplers import DefaultSampling
+from webscout.Local.formats import chatml, AdvancedFormat
+from webscout.Local.utils import download_model
+import datetime
+import sys
+import os
+
+repo_id = "YorkieOH10/granite-8b-code-instruct-Q8_0-GGUF" 
+filename = "granite-8b-code-instruct.Q8_0.gguf"
+model_path = download_model(repo_id, filename, token='')
+
+# Load the model using the downloaded path
+model = ws.Model(model_path, n_gpu_layers=10)
+
+rawdog = RawDog()
+
+# Create an AdvancedFormat and modify the system content
+# Use a lambda to generate the prompt dynamically:
+chat_format = AdvancedFormat(chatml)
+#  **Pre-format the intro_prompt string:**
+system_content = f"""
+You are a command-line coding assistant called Rawdog that generates and auto-executes Python scripts.
+
+A typical interaction goes like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+3. The compiler extracts the script and then runs it using exec(). If there will be an exception raised,
+ it will be send back to you starting with "PREVIOUS SCRIPT EXCEPTION:".
+4. In case of exception, regenerate error free script.
+
+If you need to review script outputs before completing the task, you can print the word "CONTINUE" at the end of your SCRIPT.
+This can be useful for summarizing documents or technical readouts, reading instructions before
+deciding what to do, or other tasks that require multi-step reasoning.
+A typical 'CONTINUE' interaction looks like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Determine that you need to see the output of some subprocess call to complete the task
+    iii. Write a short Python SCRIPT to print that and then print the word "CONTINUE"
+3. The compiler
+    i. Checks and runs your SCRIPT
+    ii. Captures the output and appends it to the conversation as "LAST SCRIPT OUTPUT:"
+    iii. Finds the word "CONTINUE" and sends control back to you
+4. You again:
+    i. Look at the original PROMPT + the "LAST SCRIPT OUTPUT:" to determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+5. The compiler...
+
+Please follow these conventions carefully:
+- Decline any tasks that seem dangerous, irreversible, or that you don't understand.
+- Always review the full conversation prior to answering and maintain continuity.
+- If asked for information, just print the information clearly and concisely.
+- If asked to do something, print a concise summary of what you've done as confirmation.
+- If asked a question, respond in a friendly, conversational way. Use programmatically-generated and natural language responses as appropriate.
+- If you need clarification, return a SCRIPT that prints your question. In the next interaction, continue based on the user's response.
+- Assume the user would like something concise. For example rather than printing a massive table, filter or summarize it to what's likely of interest.
+- Actively clean up any temporary processes or files you use.
+- When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
+- You can plot anything with matplotlib.
+- ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. Only the console output of the first such SCRIPT is visible to the user, so make sure that it's complete and don't bother returning anything else.
+"""
+chat_format.override('system_content', lambda: system_content)
+
+thread = ws.Thread(model, format=chat_format, sampler=DefaultSampling)
+
+while True:
+    prompt = input(">: ")
+    if prompt.lower() == "q":
+        break
+
+    response = thread.send(prompt)
+
+    # Process the response using RawDog
+    script_output = rawdog.main(response)
+
+    if script_output:
+        print(script_output)
+
+```
 ### `LLM` with internet
 ```python
 from __future__ import annotations

{webscout-3.1b0 → webscout-3.3}/webscout.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ webscout/Provider/Berlin4h.py
 webscout/Provider/Blackboxai.py
 webscout/Provider/ChatGPTUK.py
 webscout/Provider/Cohere.py
+webscout/Provider/Deepseek.py
 webscout/Provider/Gemini.py
 webscout/Provider/Groq.py
 webscout/Provider/Koboldai.py

webscout-3.1b0/LICENSE.md

@@ -1,50 +0,0 @@
-****************************************
-**** HelpingAI Simplified Universal License ****
-****************************************
-
-Version 1.0
-
-### Introduction
-
-This HelpingAI Simplified Universal License (HSUL) governs HelpingAI's content, including computer programs, scripts, datasets, documents, images, audio recordings, videos, and other digital assets. The HSUL provides simple, universal terms for accessing, modifying, and sharing resources while embracing ethical development practices.
-
-### Grant of Rights
-
-Under the HSUL, HelpingAI authorizes you to copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Content, subject to the terms and conditions detailed in this document.
-
-### Conditions
-
-To qualify for the rights granted in section 1, you must strictly adhere to the following conditions:
-
-2.1. **Redistributions of Source Code.**
-   If you redistribute the Source Code, you must include the entire HSUL with your distribution. Furthermore, you must add prominent notifications in all affected files stating:
-
-   > "This Work is released under the HelpingAI Simplified Universal License v1.0."
-
-2.2. **Binary Form Redistributions.**
-   If you distribute Binaries generated from the Source Code, you must ensure the inclusion of the following statement in your distribution:
-
-   > "This Work is based upon the HelpingAI Simplified Universally Licensed Work, under the HelpingAI Simplified Universal License v1.0."
-
-2.3. **Notification of Changes.**
-   Clearly indicate any alterations you introduce to the Source Code or Documentation via prominent comments detailing the nature and scope of the change(s). Reference the date and originator of the modifications.
-
-2.4. **Branding Attribution.**
-   Do not remove or alter any HelpingAI branding, logos, or notices included in the Content without explicit prior consent from HelpingAI.
-
-2.5. **Exclusion of Warranty.**
-   The Content is delivered "AS IS," bereft of any implicit guarantee, including — though not constrained to — warranties pertaining to marketability, applicability for a particular purpose, and non-infringement.
-
-2.6. **Limitation of Liability.**
-   To the maximum extent allowed by law, neither HelpingAI nor any contributor shall bear responsibility for any loss, personal injury, property damage, indirect, special, incidental, or consequential damages stemming from or relating to the Content or its employment.
-
-2.7. **Governing Law.**
-   This HSUL shall be managed and construed according to the laws of the jurisdiction where HelpingAI primarily operates.
-
-### Definitions
-
-3.1. **"Source Code"** signifies the preferred form for editing the Content, typically represented by human-readable programming languages, scripts, or documentation formats.
-
-3.2. **"Binaries"** denote compiled forms of the Source Code, executables, libraries, or similar artifacts built from the Source Code.
-
-By leveraging this Content, you confirm your approval of the HSUL and pledge to honor its terms and conditions. If you disagree with the HSUL's rules, refrain from engaging with the Content.

webscout-3.1b0/webscout/version.py

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