webscout 8.2.7__py3-none-any.whl → 8.2.8__py3-none-any.whl

webscout/__init__.py

@@ -26,9 +26,11 @@ __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 # Add update checker
 from .update_checker import check_for_updates
 try:
-    check_for_updates()
+    update_message = check_for_updates()
+    if update_message:
+        print(update_message)
 except Exception:
-    pass  # Silently handle any update check errors
+    pass  # Silently handle any update check errorslently handle any update check errors
 
 import logging
 logging.getLogger("webscout").addHandler(logging.NullHandler())

webscout/cli.py

@@ -1,6 +1,6 @@
 import sys
 from .swiftcli import CLI, option
-from .webscout_search import WEBS
+from .webscout_search import WEBS  # Import the WEBS class from webscout_search
 from .DWEBS import GoogleSearch  # Import GoogleSearch from DWEBS
 from .yep_search import YepSearch  # Import YepSearch from yep_search
 from .version import __version__
@@ -48,32 +48,7 @@ def version():
     """Show the version of webscout."""
     print(f"webscout version: {__version__}")
 
-@app.command()
-@option("--proxy", help="Proxy URL to use for requests")
-@option("--model", "-m", help="AI model to use", default="gpt-4o-mini", type=str)
-@option("--timeout", "-t", help="Timeout value for requests", type=int, default=10)
-def chat(proxy: str = None, model: str = "gpt-4o-mini", timeout: int = 10):
-    """Interactive AI chat using DuckDuckGo's AI."""
-    webs = WEBS(proxy=proxy, timeout=timeout)
-    
-    print(f"Using model: {model}")
-    print("Type your message and press Enter. Press Ctrl+C or type 'exit' to quit.\n")
-    
-    try:
-        while True:
-            try:
-                user_input = input(">>> ").strip()
-                if not user_input or user_input.lower() in ['exit', 'quit']:
-                    break
-                    
-                response = webs.chat(keywords=user_input, model=model)
-                print(f"\nAI: {response}\n")
-                
-            except Exception as e:
-                print(f"Error: {str(e)}\n")
-                
-    except KeyboardInterrupt:
-        print("\nChat session interrupted. Exiting...")
+
 
 @app.command()
 @option("--keywords", "-k", help="Search keywords", required=True)
@@ -546,4 +521,4 @@ def main():
         sys.exit(1)
 
 if __name__ == "__main__":
-    main()
+    main()

webscout/conversation.py

@@ -1,6 +1,24 @@
+"""
+conversation.py
+
+This module provides a modern conversation manager for handling chat-based interactions, message history, tool calls, and robust error handling. It defines the Conversation class and supporting types for managing conversational state, tool integration, and message validation.
+
+Classes:
+    ConversationError: Base exception for conversation-related errors.
+    ToolCallError: Raised when there's an error with tool calls.
+    MessageValidationError: Raised when message validation fails.
+    Message: Represents a single message in the conversation.
+    FunctionCall: TypedDict for a function call.
+    ToolDefinition: TypedDict for a tool definition.
+    FunctionCallData: TypedDict for function call data.
+    Fn: Represents a function (tool) that the agent can call.
+    Conversation: Main conversation manager class.
+
+Functions:
+    tools: Decorator to mark a function as a tool.
+"""
 import os
 import json
-import logging
 from typing import Optional, Dict, List, Any, TypedDict, Callable, TypeVar, Union
 from dataclasses import dataclass
 from datetime import datetime
@@ -59,14 +77,15 @@ def tools(func: Callable[..., T]) -> Callable[..., T]:
     return func
 
 class Conversation:
-    """Modern conversation manager with enhanced features.
-    
+    """
+    Modern conversation manager with enhanced features.
+
     Key Features:
-    - Robust message handling with metadata
-    - Enhanced tool calling support
-    - Efficient history management
-    - Improved error handling
-    - Memory optimization
+        - Robust message handling with metadata
+        - Enhanced tool calling support
+        - Efficient history management
+        - Improved error handling
+        - Memory optimization
     """
 
     intro = (
@@ -95,23 +114,8 @@ class Conversation:
         self.prompt_allowance = 10
         self.tools = tools or []
         self.compression_threshold = compression_threshold
-        self.logger = self._setup_logger()
-        
         if filepath:
-            self.load_conversation(filepath, False)
-
-    def _setup_logger(self) -> logging.Logger:
-        """Set up enhanced logging."""
-        logger = logging.getLogger("conversation")
-        if not logger.handlers:
-            handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-            )
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-            logger.setLevel(logging.INFO)
-        return logger
+            self.load_conversation(filepath, True)
 
     def load_conversation(self, filepath: str, exists: bool = True) -> None:
         """Load conversation with improved error handling."""
@@ -132,7 +136,6 @@ class Conversation:
                         self.intro = file_contents[0]
                         self._process_history_from_file(file_contents[1:])
         except Exception as e:
-            self.logger.error(f"Error loading conversation: {str(e)}")
             raise ConversationError(f"Failed to load conversation: {str(e)}") from e
 
     def _process_history_from_file(self, lines: List[str]) -> None:
@@ -272,6 +275,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
     def add_message(self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None:
         """Add a message with enhanced validation and metadata support."""
         try:
+            role = role.lower()  # Normalize role to lowercase
             if not self.validate_message(role, content):
                 raise MessageValidationError("Invalid message role or content")
 
@@ -284,7 +288,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             self._compress_history()
             
         except Exception as e:
-            self.logger.error(f"Error adding message: {str(e)}")
             raise ConversationError(f"Failed to add message: {str(e)}") from e
 
     def _append_to_file(self, message: Message) -> None:
@@ -299,17 +302,17 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 fh.write(f"\n{role_display}: {message.content}")
                 
         except Exception as e:
-            self.logger.error(f"Error writing to file: {str(e)}")
             raise ConversationError(f"Failed to write to file: {str(e)}") from e
 
     def validate_message(self, role: str, content: str) -> bool:
         """Validate message with enhanced role checking."""
         valid_roles = {'user', 'assistant', 'tool', 'system'}
         if role not in valid_roles:
-            self.logger.error(f"Invalid role: {role}")
             return False
-        if not content or not isinstance(content, str):
-            self.logger.error("Invalid content")
+        if not isinstance(content, str):
+            return False
+        # Allow empty content for assistant (needed for streaming)
+        if not content and role != 'assistant':
             return False
         return True
 
@@ -345,7 +348,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             }
             
         except Exception as e:
-            self.logger.error(f"Error handling tool response: {str(e)}")
             raise ToolCallError(f"Failed to handle tool response: {str(e)}") from e
 
     def _parse_function_call(self, response: str) -> FunctionCallData:
@@ -381,7 +383,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 raise
 
         except Exception as e:
-            self.logger.error(f"Error parsing function call: {str(e)}")
             return {"error": str(e)}
 
     def execute_function(self, function_call_data: FunctionCallData) -> str:
@@ -405,7 +406,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             return "; ".join(results)
             
         except Exception as e:
-            self.logger.error(f"Error executing function: {str(e)}")
             raise ToolCallError(f"Failed to execute function: {str(e)}") from e
 
     def get_tools_description(self) -> str:
@@ -428,9 +428,9 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         This method adds both the user's prompt and the assistant's response
         to the conversation history as separate messages.
         """
-        # Add user's message
+        # Add user's message (normalize role)
         self.add_message("user", prompt)
         
-        # Add assistant's response
+        # Add assistant's response (normalize role)
         self.add_message("assistant", response)
 

webscout/litagent/Readme.md

@@ -0,0 +1,276 @@
+# 🔥 LitAgent - The Lit User Agent Generator
+
+LitAgent is a powerful and modern user agent generator that keeps your requests fresh and undetectable! Built with style and packed with features, it's your go-to solution for managing user agents in your web scraping projects.
+
+## 🚀 Quick Start
+
+```python
+from webscout import LitAgent
+
+# Create a LitAgent instance
+agent = LitAgent()
+
+# Get a random user agent
+ua = agent.random()
+print(ua)  # Mozilla/5.0 (Windows NT 11.0) AppleWebKit/537.36 ...
+```
+
+## 🎯 Features
+
+### Browser-Specific Agents
+
+```python
+# Get agents for specific browsers
+chrome_ua = agent.chrome()    # Latest Chrome agent
+firefox_ua = agent.firefox()  # Latest Firefox agent
+safari_ua = agent.safari()    # Latest Safari agent
+edge_ua = agent.edge()       # Latest Edge agent
+opera_ua = agent.opera()     # Latest Opera agent
+```
+
+### Device-Specific Agents
+
+```python
+# Get mobile or desktop agents
+mobile_ua = agent.mobile()    # Mobile device agent
+desktop_ua = agent.desktop()  # Desktop device agent
+
+# New - Get agents for specific device types
+tablet_ua = agent.tablet()    # Tablet device agent
+tv_ua = agent.smart_tv()      # Smart TV agent
+console_ua = agent.gaming()   # Gaming console agent
+```
+
+### OS-Specific Agents
+
+```python
+# New - Get agents for specific operating systems
+windows_ua = agent.windows()  # Windows agent
+mac_ua = agent.macos()        # macOS agent
+linux_ua = agent.linux()      # Linux agent
+android_ua = agent.android()  # Android agent
+ios_ua = agent.ios()          # iOS agent
+```
+
+### Custom Agent Generation
+
+```python
+# New - Generate custom user agents with specific attributes
+custom_ua = agent.custom(
+    browser="chrome",
+    version="91.0",
+    os="windows",
+    os_version="10",
+    device_type="desktop"
+)
+```
+
+### Keep It Fresh
+
+```python
+# Refresh your agents pool anytime
+agent.refresh()  # Generates new set of agents
+
+# New - Schedule automatic refreshes
+agent.auto_refresh(interval_minutes=30)  # Auto-refresh every 30 minutes
+```
+
+## 💫 Real-World Examples
+
+### With Requests
+
+```python
+import requests
+from webscout import LitAgent
+
+agent = LitAgent()
+
+def make_request(url):
+    headers = {
+        'User-Agent': agent.random(),
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Connection': 'keep-alive',
+    }
+    return requests.get(url, headers=headers)
+
+# Make requests with different agents
+response1 = make_request('https://api.example.com')  # Random agent
+response2 = make_request('https://mobile.example.com')  # Another random agent
+```
+
+### With aiohttp
+
+```python
+import aiohttp
+import asyncio
+from webscout import LitAgent
+
+agent = LitAgent()
+
+async def fetch(url):
+    headers = {'User-Agent': agent.random()}
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            return await response.text()
+
+# Use it in your async code
+async def main():
+    urls = [
+        'https://api1.example.com',
+        'https://api2.example.com',
+        'https://api3.example.com'
+    ]
+    tasks = [fetch(url) for url in urls]
+    results = await asyncio.gather(*tasks)
+    return results
+```
+
+### With Selenium
+
+```python
+from selenium import webdriver
+from webscout import LitAgent
+
+agent = LitAgent()
+
+def create_driver():
+    options = webdriver.ChromeOptions()
+    options.add_argument(f'user-agent={agent.chrome()}')
+    return webdriver.Chrome(options=options)
+
+# Use it with Selenium
+driver = create_driver()
+driver.get('https://example.com')
+```
+
+### New - With Playwright
+
+```python
+from playwright.sync_api import sync_playwright
+from webscout import LitAgent
+
+agent = LitAgent()
+
+def browse_with_playwright():
+    with sync_playwright() as p:
+        browser_options = {
+            "user_agent": agent.chrome(),
+            "viewport": {"width": 1280, "height": 720}
+        }
+        browser = p.chromium.launch()
+        context = browser.new_context(**browser_options)
+        page = context.new_page()
+        page.goto('https://example.com')
+        # Continue with your scraping logic
+        browser.close()
+```
+
+## 🌟 Pro Tips
+
+1. **Rotate Agents**: Refresh your agents pool periodically to avoid detection
+   ```python
+   agent = LitAgent()
+   for _ in range(10):
+       response = requests.get(url, headers={'User-Agent': agent.random()})
+       if _ % 3 == 0:  # Refresh every 3 requests
+           agent.refresh()
+   ```
+
+2. **Device-Specific Scraping**: Use appropriate agents for different platforms
+   ```python
+   # Mobile site scraping
+   mobile_response = requests.get(
+       'https://m.example.com',
+       headers={'User-Agent': agent.mobile()}
+   )
+
+   # Desktop site scraping
+   desktop_response = requests.get(
+       'https://example.com',
+       headers={'User-Agent': agent.desktop()}
+   )
+   ```
+
+3. **Browser Consistency**: Stick to one browser type per session
+   ```python
+   chrome_agent = agent.chrome()
+   headers = {
+       'User-Agent': chrome_agent,
+       'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
+   }
+   # Use these headers for all requests in this session
+   ```
+
+4. **New - Browser Fingerprinting Defense**:
+   ```python
+   # Create consistent browser fingerprinting
+   fingerprint = agent.generate_fingerprint(browser="chrome")
+   
+   headers = {
+       'User-Agent': fingerprint['user_agent'],
+       'Accept-Language': fingerprint['accept_language'],
+       'Accept': fingerprint['accept'],
+       'Sec-Ch-Ua': fingerprint['sec_ch_ua'],
+       'Sec-Ch-Ua-Platform': fingerprint['platform']
+   }
+   
+   # Use this consistent set for all session requests
+   ```
+
+5. **New - Multi-threading Support**:
+   ```python
+   import concurrent.futures
+   from webscout import LitAgent
+   
+   agent = LitAgent(thread_safe=True)  # Thread-safe instance
+   
+   def fetch_url(url):
+       headers = {'User-Agent': agent.random()}
+       return requests.get(url, headers=headers).text
+   
+   urls = ['https://example1.com', 'https://example2.com', 'https://example3.com']
+   
+   with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+       results = list(executor.map(fetch_url, urls))
+   ```
+
+## 🔧 Supported Browsers & Devices
+
+- **Browsers**: Chrome, Firefox, Safari, Edge, Opera, Brave, Vivaldi
+- **Operating Systems**: Windows, macOS, Linux, Android, iOS, Chrome OS
+- **Devices**: Mobile phones, Tablets, Desktops, Game consoles, Smart TVs, Wearables
+
+## 🎨 Why LitAgent?
+
+- 🚀 Modern and up-to-date user agents
+- 💪 Easy to use, hard to detect
+- 🔄 Fresh agents on demand
+- 📱 Device-specific agents
+- 🌐 All major browsers supported
+- ⚡ Lightweight and fast
+- 🧩 Advanced fingerprinting protection
+- 🔄 Seamless proxy integration
+- 🧵 Thread-safe operation
+- 🕰️ Automatic refresh scheduling
+
+## 📊 New - Analytics and Reporting
+
+```python
+# Get statistics on your agent usage
+stats = agent.get_stats()
+print(f"Agents generated: {stats.total_generated}")
+print(f"Most used browser: {stats.top_browser}")
+print(f"Detection avoidance rate: {stats.avoidance_rate}%")
+
+# Export your usage data
+agent.export_stats('agent_usage.json')
+```
+
+## 📋 Installation
+
+```bash
+pip install webscout
+```
+
+Made with 💖 by the HelpingAI team

webscout/litagent/__init__.py

@@ -0,0 +1,29 @@
+"""
+LitAgent - A lit user agent generator with infinite possibilities! 🔥
+
+Examples:
+>>> from webscout import LitAgent
+>>> agent = LitAgent()
+>>> 
+>>> # Get random user agents
+>>> agent.random()  # Random agent from any browser
+>>> agent.mobile()  # Random mobile device agent
+>>> agent.desktop()  # Random desktop agent
+>>>
+>>> # Browser specific agents
+>>> agent.chrome()  # Latest Chrome browser
+>>> agent.firefox()  # Latest Firefox browser
+>>> agent.safari()  # Latest Safari browser
+>>> agent.edge()  # Latest Edge browser
+>>> agent.opera()  # Latest Opera browser
+>>>
+>>> # Refresh your agents
+>>> agent.refresh()  # Get fresh new agents
+"""
+
+from .agent import LitAgent
+from .constants import BROWSERS, OS_VERSIONS, DEVICES, FINGERPRINTS
+
+agent = LitAgent()
+
+__all__ = ['LitAgent', 'agent', 'BROWSERS', 'OS_VERSIONS', 'DEVICES', 'FINGERPRINTS']