webscout 6.9__py3-none-any.whl → 7.0__py3-none-any.whl

webscout/AIbase.py

@@ -1,5 +1,4 @@
-from abc import ABC
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import AsyncGenerator, List, Union, Generator, Optional
 from typing_extensions import TypeAlias
@@ -110,4 +109,15 @@ class AsyncImageProvider(ABC):
         name: Optional[str] = None,
         dir: Optional[Union[str, Path]] = None
     ) -> List[str]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AISearch(ABC):
+
+    @abstractmethod
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Response:
         raise NotImplementedError("Method needs to be implemented in subclass")

webscout/DWEBS.py

@@ -109,7 +109,7 @@ class GoogleS:
         timeout: Optional[int] = 10,
         max_workers: int = 20,
         cache_dir: Optional[str] = None,
-        rate_limit: float = 0.01,
+        rate_limit: float = 2.0,
         use_litlogger: bool = False
     ):
         """
@@ -152,7 +152,10 @@ class GoogleS:
         current_time = time.time()
         time_since_last = current_time - self.last_request_time
         if time_since_last < self.rate_limit:
-            time.sleep(self.rate_limit - time_since_last)
+            sleep_time = self.rate_limit - time_since_last
+            if self.use_litlogger:
+                self.logger.debug(f"Rate limiting: Waiting {sleep_time:.2f} seconds")
+            time.sleep(sleep_time)
         self.last_request_time = time.time()
 
     def _get_url(self, method: str, url: str, params: Optional[Dict[str, str]] = None,
@@ -170,31 +173,44 @@ class GoogleS:
         Returns:
             bytes: Response content
         """
-        self._respect_rate_limit()
+        retry_count = 0
+        base_delay = 5  # Base delay in seconds
         
-        for attempt in range(max_retries):
+        while retry_count < max_retries:
             try:
-                if self.use_litlogger:
-                    self.logger.debug(f"Making {method} request to {url} (Attempt {attempt + 1})")
+                self._respect_rate_limit()
+                response = self.client.request(
+                    method=method,
+                    url=url,
+                    params=params,
+                    data=data,
+                    timeout=self.timeout
+                )
                 
-                resp = self.client.request(method, url, params=params, data=data, timeout=self.timeout)
-                resp.raise_for_status()
+                if response.status_code == 429:
+                    retry_delay = base_delay * (2 ** retry_count)  # Exponential backoff
+                    if self.use_litlogger:
+                        self.logger.warning(f"Rate limited by Google. Waiting {retry_delay} seconds before retry...")
+                    time.sleep(retry_delay)
+                    retry_count += 1
+                    continue
+                    
+                response.raise_for_status()
+                return response.content
                 
-                if self.use_litlogger:
-                    self.logger.success(f"Request successful: {resp.status_code}")
+            except requests.exceptions.RequestException as e:
+                if retry_count == max_retries - 1:
+                    if self.use_litlogger:
+                        self.logger.error(f"Max retries reached. Last error: {str(e)}")
+                    raise
                 
-                return resp.content
-            
-            except requests.exceptions.RequestException as ex:
+                retry_delay = base_delay * (2 ** retry_count)
                 if self.use_litlogger:
-                    self.logger.error(f"Request failed: {url} - {str(ex)}")
+                    self.logger.warning(f"Request failed. Retrying in {retry_delay} seconds... Error: {str(e)}")
+                time.sleep(retry_delay)
+                retry_count += 1
                 
-                # Exponential backoff
-                if attempt < max_retries - 1:
-                    wait_time = (2 ** attempt) + random.random()
-                    time.sleep(wait_time)
-                else:
-                    raise
+        raise Exception("Max retries reached")
 
     @lru_cache(maxsize=100)
     def _cache_key(self, query: str, **kwargs) -> str:
@@ -471,7 +487,7 @@ class GoogleS:
 
 if __name__ == "__main__":
     from rich import print
-    searcher = GoogleS()
-    results = searcher.search("HelpingAI-9B", max_results=200, extract_text=False, max_text_length=200)
+    searcher = GoogleS(rate_limit=3.0, use_litlogger=True)
+    results = searcher.search("HelpingAI-9B", max_results=5, extract_text=False, max_text_length=200)
     for result in results:
         print(result)

webscout/Extra/autocoder/autocoder_utiles.py

@@ -8,14 +8,71 @@ import sys
 from typing import List, Optional
 
 from webscout.optimizers import Optimizers
-
+import os
+import platform
+import subprocess
 
 def get_current_app() -> str:
-    """Get the current active application name."""
-    try:
-        active_window: Optional[gw.Window] = gw.getActiveWindow()
-        return f"{active_window.title if active_window else 'Unknown'}"
-    except Exception as e:
+    """
+    Get the current active application or window title in a cross-platform manner.
+
+    On Windows, uses the win32gui module from pywin32.
+    On macOS, uses AppKit to access the active application info.
+    On Linux, uses xprop to get the active window details.
+
+    Returns:
+        A string containing the title of the active application/window, or "Unknown" if it cannot be determined.
+    """
+    system_name = platform.system()
+
+    if system_name == "Windows":
+        try:
+            import win32gui  # pywin32 must be installed
+            window_handle = win32gui.GetForegroundWindow()
+            title = win32gui.GetWindowText(window_handle)
+            return title if title else "Unknown"
+        except Exception:
+            return "Unknown"
+
+    elif system_name == "Darwin":  # macOS
+        try:
+            from AppKit import NSWorkspace # type: ignore
+            active_app = NSWorkspace.sharedWorkspace().activeApplication()
+            title = active_app.get('NSApplicationName')
+            return title if title else "Unknown"
+        except Exception:
+            return "Unknown"
+
+    elif system_name == "Linux":
+        try:
+            # Get the active window id using xprop
+            result = subprocess.run(
+                ["xprop", "-root", "_NET_ACTIVE_WINDOW"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            if result.returncode == 0 and result.stdout:
+                # Expected format: _NET_ACTIVE_WINDOW(WINDOW): window id # 0x1400007
+                parts = result.stdout.strip().split()
+                window_id = parts[-1]
+                if window_id != "0x0":
+                    title_result = subprocess.run(
+                        ["xprop", "-id", window_id, "WM_NAME"],
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True
+                    )
+                    if title_result.returncode == 0 and title_result.stdout:
+                        # Expected format: WM_NAME(STRING) = "Terminal"
+                        title_parts = title_result.stdout.split(" = ", 1)
+                        if len(title_parts) == 2:
+                            title = title_parts[1].strip().strip('"')
+                            return title if title else "Unknown"
+        except Exception:
+            pass
+        return "Unknown"
+    else:
         return "Unknown"
 
 
@@ -136,4 +193,8 @@ EXAMPLES: str = """
         </rawdog_response>
     </example>
 </examples>
-"""
+"""
+
+if __name__ == "__main__":
+    # Simple test harness to print the current active window title.
+    print("Current Active Window/Application: ", get_current_app())

webscout/Extra/autollama.py

@@ -1,21 +1,5 @@
 """
-Yo fam! 🔥 Welcome to AutoLlama - your go-to tool for downloading and setting up HelpingAI models! 💪
-
-Created by the legendary Abhay Koul, this script's got your back when it comes to:
-- Downloading models straight from HuggingFace Hub 🚀
-- Setting up Ollama with zero hassle 💯
-- Getting your AI assistant ready to vibe with you! ⚡
-
-Usage:
 >>> python -m webscout.Extra.autollama download -m "OEvortex/HelpingAI-Lite-1.5T" -g "HelpingAI-Lite-1.5T.q4_k_m.gguf"
-
-Features:
-- Smart model management 🧠
-- Automatic dependency installation 📦
-- Progress tracking that keeps it real 📈
-- Error handling that's got your back 💪
-
-Join the squad on Discord and level up your AI game! 🎮
 """
 
 import warnings

webscout/Extra/gguf.py

@@ -1,22 +1,9 @@
 """
-Yo fam! 🔥 Welcome to GGUF Converter - your ultimate tool for converting models to GGUF format! 💪
 
-- Converting HuggingFace models to GGUF format 🚀
-- Multiple quantization methods for different needs 🎯
-- Easy upload back to HuggingFace Hub 📤
-
-Usage:
 >>> python -m webscout.Extra.gguf convert -m "OEvortex/HelpingAI-Lite-1.5T" -q "q4_k_m,q5_k_m"
 >>> # With upload options:
 >>> python -m webscout.Extra.gguf convert -m "your-model" -u "username" -t "token" -q "q4_k_m"
 
-Features:
-- Smart dependency checking 🔍
-- CUDA support detection ⚡
-- Progress tracking that keeps it real 📈
-- Multiple quantization options 🎮
-
-Join the squad on Discord and level up your AI game! 🎮
 """
 
 import subprocess

webscout/Provider/AISEARCH/DeepFind.py

@@ -0,0 +1,251 @@
+from uuid import uuid4
+import requests
+import json
+import re
+from typing import Any, Dict, Generator, Optional
+
+from webscout.AIbase import AISearch
+from webscout import exceptions
+from webscout import LitAgent
+
+class Response:
+    """A wrapper class for DeepFind API responses.
+    
+    This class automatically converts response objects to their text representation
+    when printed or converted to string.
+    
+    Attributes:
+        text (str): The text content of the response
+        
+    Example:
+        >>> response = Response("Hello, world!")
+        >>> print(response)
+        Hello, world!
+        >>> str(response)
+        'Hello, world!'
+    """
+    def __init__(self, text: str):
+        self.text = text
+    
+    def __str__(self):
+        return self.text
+    
+    def __repr__(self):
+        return self.text
+
+class DeepFind(AISearch):
+    """A class to interact with the DeepFind AI search API.
+    
+    DeepFind provides a powerful search interface that returns AI-generated responses
+    based on web content. It supports both streaming and non-streaming responses.
+    
+    Basic Usage:
+        >>> from webscout import DeepFind
+        >>> ai = DeepFind()
+        >>> # Non-streaming example
+        >>> response = ai.search("What is Python?")
+        >>> print(response)
+        Python is a high-level programming language...
+        
+        >>> # Streaming example
+        >>> for chunk in ai.search("Tell me about AI", stream=True):
+        ...     print(chunk, end="", flush=True)
+        Artificial Intelligence is...
+        
+        >>> # Raw response format
+        >>> for chunk in ai.search("Hello", stream=True, raw=True):
+        ...     print(chunk)
+        {'text': 'Hello'}
+        {'text': ' there!'}
+    
+    Args:
+        timeout (int, optional): Request timeout in seconds. Defaults to 30.
+        proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+    
+    Attributes:
+        api_endpoint (str): The DeepFind API endpoint URL.
+        stream_chunk_size (int): Size of chunks when streaming responses.
+        timeout (int): Request timeout in seconds.
+        headers (dict): HTTP headers used in requests.
+    """
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        proxies: Optional[dict] = None,
+    ):
+        """Initialize the DeepFind API client.
+        
+        Args:
+            timeout (int, optional): Request timeout in seconds. Defaults to 30.
+            proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+        
+        Example:
+            >>> ai = DeepFind(timeout=60)  # Longer timeout
+            >>> ai = DeepFind(proxies={'http': 'http://proxy.com:8080'})  # With proxy
+        """
+        self.session = requests.Session()
+        self.api_endpoint = "https://www.deepfind.co/?q={query}"
+        self.stream_chunk_size = 1024
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Accept": "text/x-component",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "Content-Type": "text/plain;charset=UTF-8",
+            "DNT": "1",
+            "Next-Action": "f354668f23f516a46ad0abe4dedb84b19068bb54",
+            "Next-Router-State-Tree": '%5B%22%22%2C%7B%22children%22%3A%5B%22__PAGE__%3F%7B%5C%22q%5C%22%3A%5C%22hi%5C%22%7D%22%2C%7B%7D%2C%22%2F%3Fq%3Dhi%22%2C%22refresh%22%5D%7D%2Cnull%2Cnull%2Ctrue%5D',
+            "Origin": "https://www.deepfind.co",
+            "Referer": "https://www.deepfind.co/?q=hi",
+            "Sec-Ch-Ua": '"Not A(Brand";v="8", "Chromium";v="132", "Microsoft Edge";v="132"',
+            "Sec-Ch-Ua-Mobile": "?0",
+            "Sec-Ch-Ua-Platform": '"Windows"',
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "User-Agent": LitAgent().random(),
+        }
+        self.session.headers.update(self.headers)
+        self.proxies = proxies
+
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Dict[str, Any] | Generator[str, None, None]:
+        """Search using the DeepFind API and get AI-generated responses.
+        
+        This method sends a search query to DeepFind and returns the AI-generated response.
+        It supports both streaming and non-streaming modes, as well as raw response format.
+        
+        Args:
+            prompt (str): The search query or prompt to send to the API.
+            stream (bool, optional): If True, yields response chunks as they arrive.
+                                   If False, returns complete response. Defaults to False.
+            raw (bool, optional): If True, returns raw response dictionaries with 'text' key.
+                                If False, returns Response objects that convert to text automatically.
+                                Defaults to False.
+        
+        Returns:
+            Union[Dict[str, Any], Generator[str, None, None]]: 
+                - If stream=False: Returns complete response
+                - If stream=True: Yields response chunks as they arrive
+        
+        Raises:
+            APIConnectionError: If the API request fails
+        
+        Examples:
+            Basic search:
+            >>> ai = DeepFind()
+            >>> response = ai.search("What is Python?")
+            >>> print(response)
+            Python is a programming language...
+            
+            Streaming response:
+            >>> for chunk in ai.search("Tell me about AI", stream=True):
+            ...     print(chunk, end="")
+            Artificial Intelligence...
+            
+            Raw response format:
+            >>> for chunk in ai.search("Hello", stream=True, raw=True):
+            ...     print(chunk)
+            {'text': 'Hello'}
+            {'text': ' there!'}
+            
+            Error handling:
+            >>> try:
+            ...     response = ai.search("My question")
+            ... except exceptions.APIConnectionError as e:
+            ...     print(f"API error: {e}")
+        """
+        url = self.api_endpoint.format(query=prompt)
+        payload = [
+            [{"role": "user", "id": uuid4().hex, "content": prompt}],
+            uuid4().hex,
+        ]
+
+        def for_stream():
+            try:
+                with self.session.post(
+                    url,
+                    headers=self.headers,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                ) as response:
+                    response.raise_for_status()
+                    streaming_text = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line:
+                            content_matches = re.findall(r'"content":"([^"\\]*(?:\\.[^"\\]*)*)"', line)
+                            if content_matches:
+                                for content in content_matches:
+                                    if len(content) > len(streaming_text):
+                                        delta = content[len(streaming_text):]
+                                        streaming_text = content
+                                        delta = delta.replace('\\"', '"').replace('\\n', '\n')
+                                        delta = re.sub(r'\[REF\]\(https?://[^\s]*\)', '', delta)
+                                        if raw:
+                                            yield {"text": delta}
+                                        else:
+                                            yield Response(delta)
+                            description_matches = re.findall(r'"description":"([^"\\]*(?:\\.[^"\\]*)*)"', line)
+                            if description_matches:
+                                for description in description_matches:
+                                    if description and len(description) > len(streaming_text):
+                                        delta = description[len(streaming_text):]
+                                        streaming_text = description
+                                        delta = delta.replace('\\"', '"').replace('\\n', '\n')
+                                        delta = re.sub(r'\[REF\]\(https?://[^\s]*\)', '', delta)
+                                        if raw:
+                                            yield {"text": f"{delta}\n"}
+                                        else:
+                                            yield Response(f"{delta}\n")
+                    self.last_response = Response(streaming_text)
+            except requests.exceptions.RequestException as e:
+                raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+        def for_non_stream():
+            full_response = ""
+            for chunk in for_stream():
+                if raw:
+                    yield chunk
+                else:
+                    full_response += str(chunk)
+            if not raw:
+                self.last_response = Response(full_response)
+                return self.last_response
+        
+        return for_stream() if stream else for_non_stream()
+
+    @staticmethod
+    def clean_content(text: str) -> str:
+        """Removes all webblock elements with research or detail classes.
+        
+        Args:
+            text (str): The text to clean
+        
+        Returns:
+            str: The cleaned text
+        
+        Example:
+            >>> text = '<webblock class="research">...</webblock>Other text'
+            >>> cleaned_text = DeepFind.clean_content(text)
+            >>> print(cleaned_text)
+            Other text
+        """
+        cleaned_text = re.sub(
+            r'<webblock class="(?:research|detail)">[^<]*</webblock>', "", text
+        )
+        return cleaned_text
+
+
+if __name__ == "__main__":
+    from rich import print
+    ai = DeepFind()
+    response = ai.search(input(">>> "), stream=True, raw=False)
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout/Provider/AISEARCH/__init__.py

@@ -1,2 +1,2 @@
-from .felo_search import *
-from .ooai import *
+from .felo_search import Felo
+from .DeepFind import DeepFind