webscout 7.6__py3-none-any.whl → 7.7__py3-none-any.whl

webscout/Extra/gguf.py

@@ -17,7 +17,7 @@ import signal
 import tempfile
 import platform
 from pathlib import Path
-from typing import Optional, Dict, List
+from typing import Optional, Dict, List, Any, Union, Literal, TypedDict, Set
 
 from huggingface_hub import HfApi
 from webscout.zeroart import figlet_format
@@ -32,10 +32,15 @@ class ConversionError(Exception):
     """Custom exception for when things don't go as planned! ⚠️"""
     pass
 
+class QuantizationMethod(TypedDict):
+    """Type definition for quantization method descriptions."""
+    description: str
+
 class ModelConverter:
     """Handles the conversion of Hugging Face models to GGUF format."""
     
-    VALID_METHODS = {
+    VALID_METHODS: Dict[str, str] = {
+        "fp16": "16-bit floating point - maximum accuracy, largest size",
         "q2_k": "2-bit quantization (smallest size, lowest accuracy)",
         "q3_k_l": "3-bit quantization (large) - balanced for size/accuracy",
         "q3_k_m": "3-bit quantization (medium) - good balance for most use cases",
@@ -52,7 +57,7 @@ class ModelConverter:
         "q8_0": "8-bit quantization - maximum accuracy, largest size"
     }
     
-    VALID_IMATRIX_METHODS = {
+    VALID_IMATRIX_METHODS: Dict[str, str] = {
         "iq3_m": "3-bit imatrix quantization (medium) - balanced importance-based",
         "iq3_xxs": "3-bit imatrix quantization (extra extra small) - maximum compression",
         "q4_k_m": "4-bit imatrix quantization (medium) - balanced importance-based",
@@ -63,11 +68,18 @@ class ModelConverter:
         "q5_k_s": "5-bit imatrix quantization (small) - optimized for speed"
     }
     
-    def __init__(self, model_id: str, username: Optional[str] = None, 
-                 token: Optional[str] = None, quantization_methods: str = "q4_k_m",
-                 use_imatrix: bool = False, train_data_file: Optional[str] = None,
-                 split_model: bool = False, split_max_tensors: int = 256,
-                 split_max_size: Optional[str] = None):
+    def __init__(
+        self,
+        model_id: str,
+        username: Optional[str] = None,
+        token: Optional[str] = None,
+        quantization_methods: str = "q4_k_m",
+        use_imatrix: bool = False,
+        train_data_file: Optional[str] = None,
+        split_model: bool = False,
+        split_max_tensors: int = 256,
+        split_max_size: Optional[str] = None
+    ) -> None:
         self.model_id = model_id
         self.username = username
         self.token = token
@@ -79,6 +91,7 @@ class ModelConverter:
         self.split_model = split_model
         self.split_max_tensors = split_max_tensors
         self.split_max_size = split_max_size
+        self.fp16_only = "fp16" in self.quantization_methods and len(self.quantization_methods) == 1
         
     def validate_inputs(self) -> None:
         """Validates all input parameters."""
@@ -117,7 +130,7 @@ class ModelConverter:
     @staticmethod
     def check_dependencies() -> Dict[str, bool]:
         """Check if all required dependencies are installed."""
-        dependencies = {
+        dependencies: Dict[str, str] = {
             'git': 'Git version control',
             'pip3': 'Python package installer',
             'huggingface-cli': 'Hugging Face CLI',
@@ -125,7 +138,7 @@ class ModelConverter:
             'ninja': 'Ninja build system (optional)'
         }
         
-        status = {}
+        status: Dict[str, bool] = {}
         for cmd, desc in dependencies.items():
             status[cmd] = subprocess.run(['which', cmd], capture_output=True, text=True).returncode == 0
             
@@ -133,7 +146,7 @@ class ModelConverter:
     
     def detect_hardware(self) -> Dict[str, bool]:
         """Detect available hardware acceleration."""
-        hardware = {
+        hardware: Dict[str, bool] = {
             'cuda': False,
             'metal': False,
             'opencl': False,
@@ -227,7 +240,7 @@ class ModelConverter:
                 console.print(f"  {'✓' if available else '✗'} {hw.upper()}")
             
             # Configure CMake build
-            cmake_args = ['cmake', '-B', 'build']
+            cmake_args: List[str] = ['cmake', '-B', 'build']
             
             # Add hardware acceleration options
             if hardware['cuda']:
@@ -277,7 +290,7 @@ class ModelConverter:
     
     def generate_importance_matrix(self, model_path: str, train_data_path: str, output_path: str) -> None:
         """Generates importance matrix for quantization."""
-        imatrix_command = [
+        imatrix_command: List[str] = [
             "./llama.cpp/build/bin/llama-imatrix",
             "-m", model_path,
             "-f", train_data_path,
@@ -310,7 +323,7 @@ class ModelConverter:
     
     def split_model(self, model_path: str, outdir: str) -> List[str]:
         """Splits the model into smaller chunks."""
-        split_cmd = [
+        split_cmd: List[str] = [
             "./llama.cpp/build/bin/llama-gguf-split",
             "--split",
         ]
@@ -521,9 +534,20 @@ This repository is licensed under the same terms as the original model.
         
         if result.returncode != 0:
             raise ConversionError(f"Error converting to fp16: {result.stderr}")
-        
+            
+        # If fp16_only is True, we're done after fp16 conversion
+        if self.fp16_only:
+            quantized_files = [f"{self.model_name}.fp16.gguf"]
+            if self.username and self.token:
+                api.upload_file(
+                    path_or_fileobj=fp16,
+                    path_in_repo=f"{self.model_name}.fp16.gguf",
+                    repo_id=f"{self.username}/{self.model_name}-GGUF"
+                )
+            return
+            
         # Generate importance matrix if needed
-        imatrix_path = None
+        imatrix_path: Optional[str] = None
         if self.use_imatrix:
             train_data_path = self.train_data_file if self.train_data_file else "llama.cpp/groups_merged.txt"
             imatrix_path = str(Path(outdir)/"imatrix.dat")
@@ -531,7 +555,7 @@ This repository is licensed under the same terms as the original model.
         
         # Quantize model
         console.print("[bold green]Quantizing model...")
-        quantized_files = []
+        quantized_files: List[str] = []
         for method in self.quantization_methods:
             quantized_name = f"{self.model_name.lower()}-{method.lower()}"
             if self.use_imatrix:
@@ -539,7 +563,7 @@ This repository is licensed under the same terms as the original model.
             quantized_path = str(Path(outdir)/f"{quantized_name}.gguf")
             
             if self.use_imatrix:
-                quantize_cmd = [
+                quantize_cmd: List[str] = [
                     "./llama.cpp/build/bin/llama-quantize",
                     "--imatrix", imatrix_path,
                     fp16, quantized_path, method
@@ -600,11 +624,17 @@ app = CLI(
 @option("-s", "--split-model", help="Split the model into smaller chunks", is_flag=True)
 @option("--split-max-tensors", help="Maximum number of tensors per file when splitting", default=256)
 @option("--split-max-size", help="Maximum file size when splitting (e.g., '256M', '5G')", default=None)
-def convert_command(model_id: str, username: Optional[str] = None, 
-                   token: Optional[str] = None, quantization: str = "q4_k_m",
-                   use_imatrix: bool = False, train_data: Optional[str] = None,
-                   split_model: bool = False, split_max_tensors: int = 256,
-                   split_max_size: Optional[str] = None):
+def convert_command(
+    model_id: str,
+    username: Optional[str] = None,
+    token: Optional[str] = None,
+    quantization: str = "q4_k_m",
+    use_imatrix: bool = False,
+    train_data: Optional[str] = None,
+    split_model: bool = False,
+    split_max_tensors: int = 256,
+    split_max_size: Optional[str] = None
+) -> None:
     """
     Convert and quantize HuggingFace models to GGUF format! 🚀
     
@@ -644,7 +674,7 @@ def convert_command(model_id: str, username: Optional[str] = None,
         console.print(f"[red]Unexpected error: {str(e)}")
         sys.exit(1)
 
-def main():
+def main() -> None:
     """Fire up the GGUF converter! 🚀"""
     app.run()
 

webscout/Provider/AISEARCH/ISou.py

@@ -65,7 +65,6 @@ class Isou(AISearch):
         timeout: int = 120,
         proxies: Optional[dict] = None,
         model: str = "siliconflow:deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-        logging: bool = False
     ):
         """Initialize the Isou API client.
         
@@ -73,7 +72,6 @@ class Isou(AISearch):
             timeout (int, optional): Request timeout in seconds. Defaults to 120.
             proxies (dict, optional): Proxy configuration for requests. Defaults to None.
             model (str, optional): Model to use for search. Defaults to DeepSeek-R1.
-            logging (bool, optional): Enable logging. Defaults to False.
         """
         self.available_models = [
             "siliconflow:deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
@@ -115,24 +113,6 @@ class Isou(AISearch):
         self.session.headers.update(self.headers)
         self.proxies = proxies
 
-        # Initialize logger if enabled
-        if logging:
-            from webscout.Litlogger import Logger, LogFormat, ConsoleHandler
-            from webscout.Litlogger.core.level import LogLevel
-            
-            console_handler = ConsoleHandler(
-                level=LogLevel.DEBUG,
-            )
-            
-            self.logger = Logger(
-                name="Isou",                
-                level=LogLevel.DEBUG,
-                handlers=[console_handler]
-            )
-            self.logger.info("Isou initialized successfully ✨")
-        else:
-            self.logger = None
-
     def search(
         self,
         prompt: str,
@@ -268,7 +248,6 @@ if __name__ == "__main__":
     # Initialize with specific model and logging
     ai = Isou(
         model="siliconflow:deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-        logging=False
     )
     
     response = ai.search(input(">>> "), stream=True, raw=False)

webscout/Provider/AllenAI.py

@@ -37,7 +37,7 @@ class AllenAI(Provider):
         history_offset: int = 10250,
         act: str = None,
         model: str = "tulu3-405b",
-        system_prompt: str = "You are a helpful AI assistant.",
+
     ):
         """Initializes the AllenAI API client."""
         if model not in self.AVAILABLE_MODELS:
@@ -68,7 +68,6 @@ class AllenAI(Provider):
         self.session.headers.update(self.headers)
         self.session.proxies.update(proxies)
         self.model = model
-        self.system_prompt = system_prompt
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.timeout = timeout
@@ -95,19 +94,6 @@ class AllenAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    def format_prompt(self, messages):
-        """Format messages into a prompt string"""
-        formatted = []
-        for msg in messages:
-            role = msg.get("role", "")
-            content = msg.get("content", "")
-            if role == "system":
-                formatted.append(f"System: {content}")
-            elif role == "user":
-                formatted.append(f"User: {content}")
-            elif role == "assistant":
-                formatted.append(f"Assistant: {content}")
-        return "\n".join(formatted)
 
     def ask(
         self,
@@ -139,11 +125,8 @@ class AllenAI(Provider):
             "x-anonymous-user-id": self.x_anonymous_user_id
         })
         
-        # Format messages for AllenAI
-        messages = [
-            {"role": "system", "content": self.system_prompt},
-            {"role": "user", "content": conversation_prompt}
-        ]
+
+        messages = conversation_prompt
         
         # Build multipart form data
         form_data = [
@@ -154,7 +137,7 @@ class AllenAI(Provider):
             f'Content-Disposition: form-data; name="host"\r\n\r\n{host}\r\n',
             
             f'--{boundary}\r\n'
-            f'Content-Disposition: form-data; name="content"\r\n\r\n{self.format_prompt(messages)}\r\n',
+            f'Content-Disposition: form-data; name="content"\r\n\r\n{messages}\r\n',
             
             f'--{boundary}\r\n'
             f'Content-Disposition: form-data; name="private"\r\n\r\n{str(private).lower()}\r\n'

webscout/Provider/ChatGPTClone.py

@@ -0,0 +1,226 @@
+import time
+import uuid
+import cloudscraper
+import json
+import re
+from typing import Any, Dict, Optional, Generator, Union
+from dataclasses import dataclass, asdict
+from datetime import date
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider
+from webscout import WEBS, exceptions
+from webscout.litagent import LitAgent
+
+class ChatGPTClone(Provider):
+    """
+    ChatGPTClone is a provider class for interacting with the ChatGPT Clone API.
+    Supports streaming responses.
+    """
+    
+    url = "https://chatgpt-clone-ten-nu.vercel.app"
+    AVAILABLE_MODELS = ["gpt-4", "gpt-3.5-turbo"]
+    
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2000,
+        timeout: int = 60,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "gpt-4",
+        temperature: float = 0.6,
+        top_p: float = 0.7,
+        browser: str = "chrome",
+        system_prompt: str = "You are a helpful assistant."
+    ):
+        """Initialize the ChatGPT Clone client."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            
+        self.model = model
+        self.session = cloudscraper.create_scraper()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.temperature = temperature
+        self.top_p = top_p
+        self.system_prompt = system_prompt
+
+        # Initialize LitAgent for user agent generation
+        self.agent = LitAgent()
+        # Use fingerprinting to create a consistent browser identity
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Use the fingerprint for headers
+        self.headers = {
+            "Accept": self.fingerprint["accept"],
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Content-Type": "application/json",
+            "DNT": "1",
+            "Origin": self.url,
+            "Referer": f"{self.url}/",
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+        }
+        
+        # Create session cookies with unique identifiers
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+
+        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
+        
+        # Set consistent headers for the scraper session
+        for header, value in self.headers.items():
+            self.session.headers[header] = value
+
+    def refresh_identity(self, browser: str = None):
+        """Refreshes the browser identity fingerprint."""
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        
+        # Update headers with new fingerprint
+        self.headers.update({
+            "Accept": self.fingerprint["accept"],
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or self.headers["Sec-CH-UA"],
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+        })
+        
+        # Update session headers
+        for header, value in self.headers.items():
+            self.session.headers[header] = value
+        
+        # Generate new cookies
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+        
+        return self.fingerprint
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """Send a message to the ChatGPT Clone API"""
+        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}"
+                )
+
+        payload = {
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": conversation_prompt}
+            ],
+            "model": self.model
+        }
+
+        def for_stream():
+            try:
+                with self.session.post(f"{self.url}/api/chat", headers=self.headers, cookies=self.cookies, json=payload, stream=True, timeout=self.timeout) as response:
+                    if not response.ok:
+                        # If we get a non-200 response, try refreshing our identity once
+                        if response.status_code in [403, 429]:
+                            self.refresh_identity()
+                            # Retry with new identity
+                            with self.session.post(f"{self.url}/api/chat", headers=self.headers, cookies=self.cookies, json=payload, stream=True, timeout=self.timeout) as retry_response:
+                                if not retry_response.ok:
+                                    raise exceptions.FailedToGenerateResponseError(
+                                        f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
+                                    )
+                                response = retry_response
+                        else:
+                            raise exceptions.FailedToGenerateResponseError(
+                                f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                            )
+
+                    streaming_text = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line:
+                            match = re.search(r'0:"(.*?)"', line)
+                            if match:
+                                content = match.group(1)
+                                streaming_text += content
+                                yield content if raw else dict(text=content)
+                                
+                    self.last_response.update(dict(text=streaming_text))
+                    self.conversation.update_chat_history(prompt, streaming_text)
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+
+        def for_non_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,
+    ) -> Union[str, Generator[str, None, None]]:
+        """Generate a response to a prompt"""
+        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:
+        """Extract message text from response"""
+        assert isinstance(response, dict)
+        formatted_text = response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        return formatted_text
+
+if __name__ == "__main__":
+    from rich import print
+    ai = ChatGPTClone(timeout=5000)
+    response = ai.chat("write a poem about AI", stream=True)
+    for chunk in response:
+        print(chunk, end="", flush=True) 

webscout/Provider/Glider.py

@@ -124,10 +124,14 @@ class GliderAI(Provider):
                     if value.startswith("data: "):
                         try:
                             data = json.loads(value[6:])
-                            content = data['choices'][0].get('delta', {}).get("content", "")
-                            if content:
-                                streaming_text += content
-                                yield content if raw else {"text": content}
+                            # Handle both standard and DeepSeek response formats
+                            if "choices" in data and len(data["choices"]) > 0:
+                                choice = data["choices"][0]
+                                if "delta" in choice and "content" in choice["delta"]:
+                                    content = choice["delta"]["content"]
+                                    if content:
+                                        streaming_text += content
+                                        yield content if raw else {"text": content}
                         except json.JSONDecodeError:
                             if "stop" in value:
                                 break