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

webscout/cli.py

@@ -1,34 +1,12 @@
-import os
 import sys
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from urllib.parse import unquote
-from pathlib import Path
-from .swiftcli import CLI, option, argument, group
-from curl_cffi import requests
-import pyreqwest_impersonate as pri
+from .swiftcli import CLI, option
 from .webscout_search import WEBS
-from .utils import json_dumps, json_loads
 from .version import __version__
-from .Litlogger import LitLogger, LogFormat, ColorScheme
 from rich.console import Console
 from rich.panel import Panel
-from rich.markdown import Markdown
 from rich.table import Table
-from rich.style import Style
 from rich.text import Text
-from rich.align import Align
-from rich.progress import track, Progress
-from rich.prompt import Prompt, Confirm
-from rich.columns import Columns
-from pyfiglet import figlet_format
 
-logger = LitLogger(
-    name="webscout",
-    format=LogFormat.MODERN_EMOJI,
-    color_scheme=ColorScheme.CYBERPUNK,
-    console_output=True
-)
 
 COLORS = {
     0: "black",
@@ -71,6 +49,42 @@ def _print_data(data):
             console.print(Panel(table, title=f"Result {i}", expand=False, style="green on black"))
             console.print("\n")
 
+def _print_weather(data):
+    """Prints weather data in a clean, focused format."""
+    console = Console()
+    
+    # Current weather panel
+    current = data["current"]
+    current_table = Table(show_header=False, show_lines=True, expand=True, box=None)
+    current_table.add_column("Metric", style="cyan", no_wrap=True, width=15)
+    current_table.add_column("Value", style="white")
+    
+    current_table.add_row("Temperature", f"{current['temperature_c']}°C")
+    current_table.add_row("Feels Like", f"{current['feels_like_c']}°C")
+    current_table.add_row("Humidity", f"{current['humidity']}%")
+    current_table.add_row("Wind", f"{current['wind_speed_ms']} m/s")
+    current_table.add_row("Direction", f"{current['wind_direction']}°")
+    
+    console.print(Panel(current_table, title=f"Current Weather in {data['location']}", expand=False, style="green on black"))
+    console.print("\n")
+    
+    # Daily forecast panel
+    daily_table = Table(show_header=True, show_lines=True, expand=True, box=None)
+    daily_table.add_column("Date", style="cyan")
+    daily_table.add_column("Condition", style="white")
+    daily_table.add_column("High", style="red")
+    daily_table.add_column("Low", style="blue")
+    
+    for day in data["daily_forecast"][:5]:  # Show next 5 days
+        daily_table.add_row(
+            day["date"],
+            day["condition"],
+            f"{day['max_temp_c']}°C",
+            f"{day['min_temp_c']}°C"
+        )
+    
+    console.print(Panel(daily_table, title="5-Day Forecast", expand=False, style="green on black"))
+
 # Initialize CLI app
 app = CLI(name="webscout", help="Search the web with a rich UI", version=__version__)
 
@@ -89,7 +103,7 @@ def chat(proxy: str = None, model: str = "gpt-4o-mini"):
     console = Console()
     
     # Display header
-    console.print(f"[bold blue]{figlet_format('Webscout Chat')}[/]\n", justify="center")
+    # console.print(f"[bold blue]{figlet_format('Webscout Chat')}[/]\n", justify="center")
     console.print(f"[bold green]Using model:[/] {model}\n")
     console.print("[cyan]Type your message and press Enter. Press Ctrl+C or type 'exit' to quit.[/]\n")
     
@@ -97,23 +111,18 @@ def chat(proxy: str = None, model: str = "gpt-4o-mini"):
     try:
         while True:
             try:
-                user_input = input("You: ").strip()
+                user_input = input(">>> ").strip()
                 if not user_input or user_input.lower() in ['exit', 'quit']:
                     break
                     
-                logger.info(f"Sending message to {model}")
                 response = webs.chat(keywords=user_input, model=model)
                 console.print(f"\nAI: {response}\n")
-                logger.success("Received response from AI")
                 
             except Exception as e:
-                logger.error(f"Error in chat: {str(e)}")
                 console.print(f"[bold red]Error:[/] {str(e)}\n")
                 
     except KeyboardInterrupt:
-        logger.info("Chat session terminated by user")
-        
-    console.print("\n[cyan]Chat session ended. Goodbye![/]")
+        console.print("\n[bold red]Chat session interrupted. Exiting...[/]")
 
 @app.command()
 @option("--keywords", "-k", help="Search keywords", required=True)
@@ -130,7 +139,6 @@ def text(keywords: str, region: str, safesearch: str, timelimit: str, backend: s
         results = webs.text(keywords, region, safesearch, timelimit, backend, max_results)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in text search: {e}")
         raise e
 
 @app.command()
@@ -143,7 +151,6 @@ def answers(keywords: str, proxy: str = None):
         results = webs.answers(keywords)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in answers search: {e}")
         raise e
 
 @app.command()
@@ -177,7 +184,6 @@ def images(
         results = webs.images(keywords, region, safesearch, timelimit, size, color, type, layout, license, max_results)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in images search: {e}")
         raise e
 
 @app.command()
@@ -207,7 +213,6 @@ def videos(
         results = webs.videos(keywords, region, safesearch, timelimit, resolution, duration, license, max_results)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in videos search: {e}")
         raise e
 
 @app.command()
@@ -224,7 +229,6 @@ def news(keywords: str, region: str, safesearch: str, timelimit: str, max_result
         results = webs.news(keywords, region, safesearch, timelimit, max_results)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in news search: {e}")
         raise e
 
 @app.command()
@@ -275,7 +279,6 @@ def maps(
         )
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in maps search: {e}")
         raise e
 
 @app.command()
@@ -290,7 +293,6 @@ def translate(keywords: str, from_: str, to: str, proxy: str = None):
         results = webs.translate(keywords, from_, to)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in translation: {e}")
         raise e
 
 @app.command()
@@ -304,7 +306,19 @@ def suggestions(keywords: str, region: str, proxy: str = None):
         results = webs.suggestions(keywords, region)
         _print_data(results)
     except Exception as e:
-        logger.error(f"Error in suggestions search: {e}")
+        raise e
+
+@app.command()
+@option("--location", "-l", help="Location to get weather for", required=True)
+@option("--language", "-lang", help="Language code (e.g. 'en', 'es')", default="en")
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def weather(location: str, language: str, proxy: str = None):
+    """Get weather information for a location from DuckDuckGo."""
+    webs = WEBS(proxy=proxy)
+    try:
+        results = webs.weather(location, language)
+        _print_weather(results)
+    except Exception as e:
         raise e
 
 def main():
@@ -312,7 +326,6 @@ def main():
     try:
         app.run()
     except Exception as e:
-        logger.error(f"Error: {e}")
         sys.exit(1)
 
 if __name__ == "__main__":

webscout/conversation.py

@@ -1,13 +1,6 @@
 import os
-import logging
 from typing import Optional
-from .Litlogger import Logger, LogFormat
 
-# Create a logger instance for this module
-logger = Logger(
-    name="Conversation",
-    format=LogFormat.MODERN_EMOJI,
-)
 
 class Conversation:
     """Handles prompt generation based on history and maintains chat context.
@@ -79,11 +72,9 @@ 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", encoding="utf-8") as fh:
                 fh.write(self.intro)
         else:
-            logging.debug(f"Loading conversation from '{filepath}'")
             with open(filepath, encoding="utf-8") as fh:
                 file_contents = fh.readlines()
                 if file_contents:
@@ -221,7 +212,7 @@ class Conversation:
         if role in role_formats:
             self.chat_history += f"\n{role_formats[role]} : {content}"
         else:
-            logger.warning(f"Unknown role '{role}' for message: {content}")
+            raise ValueError(f"Invalid role: {role}. Must be one of {list(role_formats.keys())}")
 
     #     # Enhanced logging for message addition
     #     logger.info(f"Added message from {role}: {content}")

webscout/litagent/__init__.py

@@ -22,8 +22,8 @@ Examples:
 """
 
 from .agent import LitAgent
-from .constants import BROWSERS, OS_VERSIONS, DEVICES
+from .constants import BROWSERS, OS_VERSIONS, DEVICES, FINGERPRINTS
 
 agent = LitAgent()
 
-__all__ = ['LitAgent', 'agent', 'BROWSERS', 'OS_VERSIONS', 'DEVICES']
+__all__ = ['LitAgent', 'agent', 'BROWSERS', 'OS_VERSIONS', 'DEVICES', 'FINGERPRINTS']

webscout/litagent/agent.py

@@ -1,21 +1,31 @@
 """Main LitAgent implementation."""
 
 import random
-from typing import List
-from webscout.Litlogger import Logger, LogFormat
-from webscout.litagent.constants import BROWSERS, OS_VERSIONS, DEVICES
+import threading
+from typing import List, Dict, Any, Optional
+
+from webscout.litagent.constants import BROWSERS, OS_VERSIONS, DEVICES, FINGERPRINTS
 
-logger = Logger(
-    name="LitAgent",
-    format=LogFormat.MODERN_EMOJI,
-)
 
 class LitAgent:
     """A lit user agent generator that keeps it fresh! 🌟"""
 
-    def __init__(self):
-        """Initialize LitAgent with style! 💫"""
+    def __init__(self, thread_safe: bool = False):
+        """Initialize LitAgent with style! 💫
+
+        Args:
+            thread_safe (bool): Enable thread-safety for multi-threaded applications
+        """
         self.agents = self._generate_agents(100)  # Keep 100 agents in memory
+        self.thread_safe = thread_safe
+        self.lock = threading.RLock() if thread_safe else None
+        self._refresh_timer = None
+        self._stats = {
+            "total_generated": 100,
+            "requests_served": 0,
+            "browser_usage": {browser: 0 for browser in BROWSERS.keys()},
+            "device_usage": {device: 0 for device in DEVICES.keys()}
+        }
 
     def _generate_agents(self, count: int) -> List[str]:
         """Generate some lit user agents! 🛠️"""
@@ -24,7 +34,7 @@ class LitAgent:
             browser = random.choice(list(BROWSERS.keys()))
             version = random.randint(*BROWSERS[browser])
             
-            if browser in ['chrome', 'firefox', 'edge', 'opera']:
+            if browser in ['chrome', 'firefox', 'edge', 'opera', 'brave', 'vivaldi']:
                 os_type = random.choice(['windows', 'mac', 'linux'])
                 os_ver = random.choice(OS_VERSIONS[os_type])
                 
@@ -44,6 +54,10 @@ class LitAgent:
                     agent += f"Edge/{version}.0.0.0"
                 elif browser == 'opera':
                     agent += f"OPR/{version}.0.0.0"
+                elif browser == 'brave':
+                    agent += f"Chrome/{version}.0.0.0 Safari/537.36 Brave/{version}.0.0.0"
+                elif browser == 'vivaldi':
+                    agent += f"Chrome/{version}.0.0.0 Safari/537.36 Vivaldi/{version}.0.{random.randint(1000, 9999)}"
             
             elif browser == 'safari':
                 device = random.choice(['mac', 'ios'])
@@ -60,29 +74,127 @@ class LitAgent:
         
         return list(set(agents))  # Remove any duplicates
 
+    def _update_stats(self, browser_type=None, device_type=None):
+        """Update usage statistics."""
+        if self.thread_safe and self.lock:
+            with self.lock:
+                self._stats["requests_served"] += 1
+                if browser_type:
+                    self._stats["browser_usage"][browser_type] = self._stats["browser_usage"].get(browser_type, 0) + 1
+                if device_type:
+                    self._stats["device_usage"][device_type] = self._stats["device_usage"].get(device_type, 0) + 1
+        else:
+            self._stats["requests_served"] += 1
+            if browser_type:
+                self._stats["browser_usage"][browser_type] = self._stats["browser_usage"].get(browser_type, 0) + 1
+            if device_type:
+                self._stats["device_usage"][device_type] = self._stats["device_usage"].get(device_type, 0) + 1
+
     def random(self) -> str:
         """Get a random user agent! 🎲"""
-        return random.choice(self.agents)
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agent = random.choice(self.agents)
+                self._update_stats()
+                return agent
+        else:
+            agent = random.choice(self.agents)
+            self._update_stats()
+            return agent
 
     def browser(self, name: str) -> str:
         """Get a browser-specific agent! 🌐"""
         name = name.lower()
         if name not in BROWSERS:
-            logger.warning(f"Unknown browser: {name} - Using random browser")
             return self.random()
         
-        agents = [a for a in self.agents if name in a.lower()]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if name in a.lower()]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(browser_type=name)
+                return agent
+        else:
+            agents = [a for a in self.agents if name in a.lower()]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(browser_type=name)
+            return agent
 
     def mobile(self) -> str:
         """Get a mobile device agent! 📱"""
-        agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="mobile")
+                return agent
+        else:
+            agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="mobile")
+            return agent
 
     def desktop(self) -> str:
         """Get a desktop agent! 💻"""
-        agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="desktop")
+                return agent
+        else:
+            agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="desktop")
+            return agent
+
+    def tablet(self) -> str:
+        """Get a tablet agent! 📱"""
+        if self.thread_safe and self.lock:
+            with self.lock:
+                # Focus on iPad and Android tablets
+                agents = [a for a in self.agents if 'iPad' in a or 'Android' in a and not 'Mobile' in a]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="tablet")
+                return agent
+        else:
+            agents = [a for a in self.agents if 'iPad' in a or 'Android' in a and not 'Mobile' in a]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="tablet")
+            return agent
+
+    def smart_tv(self) -> str:
+        """Get a Smart TV agent! 📺"""
+        # Create a TV-specific agent since they may not be in our standard pool
+        tv_type = random.choice(DEVICES['tv'])
+        if 'Samsung' in tv_type:
+            agent = f"Mozilla/5.0 (SMART-TV; SAMSUNG; {tv_type}; Tizen 5.5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.38 Safari/537.36"
+        elif 'LG' in tv_type:
+            agent = f"Mozilla/5.0 (Web0S; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        elif 'Android' in tv_type:
+            agent = f"Mozilla/5.0 (Linux; Android 9; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        elif 'Apple' in tv_type:
+            agent = f"Mozilla/5.0 (AppleTV; CPU like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+        else:
+            agent = f"Mozilla/5.0 (Linux; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        
+        self._update_stats(device_type="tv")
+        return agent
+
+    def gaming(self) -> str:
+        """Get a gaming console agent! 🎮"""
+        console_type = random.choice(DEVICES['console'])
+        if 'PlayStation' in console_type:
+            agent = f"Mozilla/5.0 ({console_type}/5.0) AppleWebKit/601.2 (KHTML, like Gecko)"
+        elif 'Xbox' in console_type:
+            agent = f"Mozilla/5.0 ({console_type}; Xbox; Xbox One) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19041"
+        elif 'Nintendo' in console_type:
+            agent = f"Mozilla/5.0 (Nintendo Switch; {console_type}) AppleWebKit/601.6 (KHTML, like Gecko) NintendoBrowser/5.1.0.13343"
+        else:
+            agent = self.random()
+        
+        self._update_stats(device_type="console")
+        return agent
 
     def chrome(self) -> str:
         """Get a Chrome agent! 🌐"""
@@ -103,10 +215,225 @@ class LitAgent:
     def opera(self) -> str:
         """Get an Opera agent! 🎭"""
         return self.browser('opera')
+    
+    def brave(self) -> str:
+        """Get a Brave agent! 🦁"""
+        return self.browser('brave')
+    
+    def vivaldi(self) -> str:
+        """Get a Vivaldi agent! 🎨"""
+        return self.browser('vivaldi')
+    
+    # OS-specific agents
+    def windows(self) -> str:
+        """Get a Windows agent! 🪟"""
+        agents = [a for a in self.agents if 'Windows' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def macos(self) -> str:
+        """Get a macOS agent! 🍎"""
+        agents = [a for a in self.agents if 'Macintosh' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def linux(self) -> str:
+        """Get a Linux agent! 🐧"""
+        agents = [a for a in self.agents if 'Linux' in a and 'Android' not in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def android(self) -> str:
+        """Get an Android agent! 🤖"""
+        agents = [a for a in self.agents if 'Android' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def ios(self) -> str:
+        """Get an iOS agent! 📱"""
+        agents = [a for a in self.agents if 'iPhone' in a or 'iPad' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+
+    def custom(self, browser: str, version: Optional[str] = None, 
+               os: Optional[str] = None, os_version: Optional[str] = None, 
+               device_type: Optional[str] = None) -> str:
+        """Generate a custom user agent with specified parameters! 🛠️
+        
+        Args:
+            browser: Browser name (chrome, firefox, safari, edge, opera)
+            version: Browser version (optional)
+            os: Operating system (windows, mac, linux, android, ios)
+            os_version: OS version (optional)
+            device_type: Device type (desktop, mobile, tablet)
+            
+        Returns:
+            Customized user agent string
+        """
+        browser = browser.lower() if browser else 'chrome'
+        if browser not in BROWSERS:
+            browser = 'chrome'
+            
+        if version:
+            try:
+                version_num = int(version.split('.')[0])
+            except (ValueError, IndexError):
+                version_num = random.randint(*BROWSERS[browser])
+        else:
+            version_num = random.randint(*BROWSERS[browser])
+            
+        os = os.lower() if os else random.choice(['windows', 'mac', 'linux'])
+        if os not in OS_VERSIONS:
+            os = 'windows'
+            
+        os_ver = os_version or random.choice(OS_VERSIONS[os])
+        
+        device_type = device_type.lower() if device_type else 'desktop'
+        
+        # Build the user agent
+        if os == 'windows':
+            platform = f"Windows NT {os_ver}"
+        elif os == 'mac':
+            platform = f"Macintosh; Intel Mac OS X {os_ver}"
+        elif os == 'linux':
+            platform = f"X11; Linux {OS_VERSIONS['linux'][0]}"
+        elif os == 'android':
+            platform = f"Linux; Android {os_ver}; {random.choice(DEVICES['mobile'])}"
+        elif os == 'ios':
+            device = 'iPhone' if device_type == 'mobile' else 'iPad'
+            platform = f"{device}; CPU OS {os_ver} like Mac OS X"
+        else:
+            platform = f"Windows NT 10.0"  # Default fallback
+        
+        agent = f"Mozilla/5.0 ({platform}) AppleWebKit/537.36 (KHTML, like Gecko) "
+        
+        if browser == 'chrome':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36"
+        elif browser == 'firefox':
+            agent += f"Firefox/{version_num}.0"
+        elif browser == 'safari':
+            safari_ver = random.randint(*BROWSERS['safari'])
+            agent += f"Version/{version_num}.0 Safari/{safari_ver}.0"
+        elif browser == 'edge':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 Edg/{version_num}.0.0.0"
+        elif browser == 'opera':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 OPR/{version_num}.0.0.0"
+        elif browser == 'brave':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 Brave/{version_num}.1.0"
+        
+        self._update_stats(browser_type=browser, device_type=device_type)
+        return agent
+
+    def generate_fingerprint(self, browser: Optional[str] = None) -> Dict[str, str]:
+        """Generate a consistent browser fingerprint! 👆
+        
+        This creates a coherent set of headers for anti-fingerprinting.
+        
+        Args:
+            browser: Specific browser to generate fingerprint for
+            
+        Returns:
+            Dictionary with fingerprinting headers
+        """
+        # Get a random user agent using the random() method
+        user_agent = self.random()
+        
+        # If browser is specified, try to get a matching one
+        if browser:
+            browser = browser.lower()
+            if browser in BROWSERS:
+                user_agent = self.browser(browser)
+        
+        accept_language = random.choice(FINGERPRINTS["accept_language"])
+        accept = random.choice(FINGERPRINTS["accept"])
+        platform = random.choice(FINGERPRINTS["platforms"])
+        
+        # Generate sec-ch-ua based on the user agent
+        sec_ch_ua = ""
+        for browser_name in FINGERPRINTS["sec_ch_ua"]:
+            if browser_name in user_agent.lower():
+                version = random.randint(*BROWSERS[browser_name])
+                sec_ch_ua = FINGERPRINTS["sec_ch_ua"][browser_name].format(version, version)
+                break
+        
+        fingerprint = {
+            "user_agent": user_agent,
+            "accept_language": accept_language,
+            "accept": accept,
+            "sec_ch_ua": sec_ch_ua,
+            "platform": platform
+        }
+        
+        self._update_stats(browser_type=browser)
+        return fingerprint
 
     def refresh(self) -> None:
         """Refresh the agents with new ones! 🔄"""
-        self.agents = self._generate_agents(100)
+        if self.thread_safe and self.lock:
+            with self.lock:
+                self.agents = self._generate_agents(100)
+                self._stats["total_generated"] += 100
+        else:
+            self.agents = self._generate_agents(100)
+            self._stats["total_generated"] += 100
+        
+
+    def auto_refresh(self, interval_minutes: int = 30) -> None:
+        """Set up automatic refreshing of agents pool! ⏱️
+        
+        Args:
+            interval_minutes: Minutes between refreshes
+        """
+        if self._refresh_timer:
+            self._refresh_timer.cancel()
+            
+        def _refresh_task():
+            self.refresh()
+            self._refresh_timer = threading.Timer(interval_minutes * 60, _refresh_task)
+            self._refresh_timer.daemon = True
+            self._refresh_timer.start()
+        
+        self._refresh_timer = threading.Timer(interval_minutes * 60, _refresh_task)
+        self._refresh_timer.daemon = True
+        self._refresh_timer.start()
+        
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about agent usage! 📊
+        
+        Returns:
+            Dictionary with usage statistics
+        """
+        stats_copy = self._stats.copy()
+        # Calculate top browser
+        top_browser = max(stats_copy["browser_usage"].items(), key=lambda x: x[1])[0] if stats_copy["browser_usage"] else None
+        stats_copy["top_browser"] = top_browser
+        
+        # Calculate fake detection avoidance rate (just for fun)
+        stats_copy["avoidance_rate"] = min(99.9, 90 + (stats_copy["total_generated"] / 1000))
+        
+        return stats_copy
+        
+    def export_stats(self, filename: str) -> bool:
+        """Export usage statistics to a file! 💾
+        
+        Args:
+            filename: Path to export the stats
+            
+        Returns:
+            True if export was successful, False otherwise
+        """
+        try:
+            import json
+            with open(filename, 'w') as f:
+                json.dump(self.get_stats(), f, indent=2)
+            return True
+        except Exception as e:
+            return False
 
 if __name__ == "__main__":
     # Test it out! 🧪
@@ -116,4 +443,13 @@ if __name__ == "__main__":
     print("Firefox:", agent.firefox())
     print("Safari:", agent.safari())
     print("Mobile:", agent.mobile())
-    print("Desktop:", agent.desktop())
+    print("Desktop:", agent.desktop())
+    print("Tablet:", agent.tablet())
+    print("Smart TV:", agent.smart_tv())
+    print("Gaming:", agent.gaming())
+    
+    # Test custom agent
+    print("Custom:", agent.custom(browser="chrome", os="windows", os_version="10.0"))
+    
+    # Test fingerprinting
+    print("Fingerprint:", agent.generate_fingerprint("chrome"))