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

webscout/litagent/constants.py

@@ -6,7 +6,9 @@ BROWSERS = {
     "firefox": (48, 121),
     "safari": (605, 617),
     "edge": (79, 120),
-    "opera": (48, 104)
+    "opera": (48, 104),
+    "brave": (100, 120),
+    "vivaldi": (5, 6)
 }
 
 # OS versions
@@ -15,7 +17,8 @@ OS_VERSIONS = {
     "mac": ["10_15_7", "11_0", "12_0", "13_0", "14_0"],
     "linux": ["x86_64", "i686"],
     "android": ["10", "11", "12", "13", "14"],
-    "ios": ["14_0", "15_0", "16_0", "17_0"]
+    "ios": ["14_0", "15_0", "16_0", "17_0"],
+    "chrome_os": ["13.0", "14.0", "15.0"]
 }
 
 # Device types
@@ -25,7 +28,33 @@ DEVICES = {
         "OnePlus", "Xiaomi", "Huawei", "OPPO", "Vivo"
     ],
     "desktop": ["Windows PC", "MacBook", "iMac", "Linux Desktop"],
-    "tablet": ["iPad", "Samsung Galaxy Tab", "Microsoft Surface"],
-    "console": ["PlayStation 5", "Xbox Series X", "Nintendo Switch"],
-    "tv": ["Samsung Smart TV", "LG WebOS", "Android TV", "Apple TV"]
+    "tablet": ["iPad", "Samsung Galaxy Tab", "Microsoft Surface", "Huawei MatePad", "Lenovo Tab"],
+    "console": ["PlayStation 5", "Xbox Series X", "Nintendo Switch", "PlayStation 4", "Xbox One"],
+    "tv": ["Samsung Smart TV", "LG WebOS", "Android TV", "Apple TV", "Sony Bravia"],
+    "wearable": ["Apple Watch", "Samsung Galaxy Watch", "Fitbit", "Garmin"]
+}
+
+# Browser fingerprinting components
+FINGERPRINTS = {
+    "accept_language": [
+        "en-US,en;q=0.9", 
+        "en-GB,en;q=0.8,en-US;q=0.6", 
+        "es-ES,es;q=0.9,en;q=0.8",
+        "fr-FR,fr;q=0.9,en;q=0.8", 
+        "de-DE,de;q=0.9,en;q=0.8"
+    ],
+    "accept": [
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"
+    ],
+    "sec_ch_ua": {
+        "chrome": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"{}\", \"Google Chrome\";v=\"{}\"",
+        "edge": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"{}\", \"Microsoft Edge\";v=\"{}\"",
+        "firefox": "\"Firefox\";v=\"{}\", \"Not;A=Brand\";v=\"8\"",
+        "safari": "\"Safari\";v=\"{}\", \"Not;A=Brand\";v=\"99\""
+    },
+    "platforms": [
+        "Windows", "macOS", "Linux", "Android", "iOS"
+    ]
 }

webscout/litprinter/__init__.py

@@ -5,11 +5,8 @@ import time
 import threading
 import re
 from typing import Any, Optional, TextIO, Union, Sequence, Dict, List
-from datetime import datetime
 import textwrap
-from collections import defaultdict
 import shutil
-import inspect
 from .colors import Colors
 import ctypes
 

webscout/models.py

@@ -0,0 +1,181 @@
+import importlib
+import pkgutil
+from typing import Dict, List, Any, Union
+from webscout.AIbase import Provider, TTSProvider
+
+class _LLMModels:
+    """
+    A class for managing LLM provider models in the webscout package.
+    """
+    
+    def list(self) -> Dict[str, List[str]]:
+        """
+        Gets all available models from each provider that has an AVAILABLE_MODELS attribute.
+        
+        Returns:
+            Dictionary mapping provider names to their available models
+        """
+        return self._get_provider_models()
+    
+    def get(self, provider_name: str) -> List[str]:
+        """
+        Gets all available models for a specific provider.
+        
+        Args:
+            provider_name: The name of the provider
+            
+        Returns:
+            List of available models for the provider
+        """
+        all_models = self._get_provider_models()
+        return all_models.get(provider_name, [])
+    
+    def summary(self) -> Dict[str, int]:
+        """
+        Returns a summary of available providers and models.
+        
+        Returns:
+            Dictionary with provider and model counts
+        """
+        provider_models = self._get_provider_models()
+        total_providers = len(provider_models)
+        total_models = sum(len(models) if isinstance(models, (list, tuple, set)) 
+                          else 1 for models in provider_models.values())
+        
+        return {
+            "providers": total_providers,
+            "models": total_models,
+            "provider_model_counts": {
+                provider: len(models) if isinstance(models, (list, tuple, set)) else 1
+                for provider, models in provider_models.items()
+            }
+        }
+    
+    def _get_provider_models(self) -> Dict[str, List[str]]:
+        """
+        Internal method to get all available models from each provider.
+        
+        Returns:
+            Dictionary mapping provider names to their available models
+        """
+        provider_models = {}
+        provider_package = importlib.import_module("webscout.Provider")
+        
+        for _, module_name, _ in pkgutil.iter_modules(provider_package.__path__):
+            try:
+                module = importlib.import_module(f"webscout.Provider.{module_name}")
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    if isinstance(attr, type) and issubclass(attr, Provider) and attr != Provider:
+                        if hasattr(attr, 'AVAILABLE_MODELS'):
+                            # Convert any sets to lists to ensure serializability
+                            models = attr.AVAILABLE_MODELS
+                            if isinstance(models, set):
+                                models = list(models)
+                            provider_models[attr_name] = models
+            except Exception:
+                pass
+        
+        return provider_models
+
+class _TTSModels:
+    """
+    A class for managing TTS provider voices in the webscout package.
+    """
+    
+    def list(self) -> Dict[str, List[str]]:
+        """
+        Gets all available voices from each TTS provider that has an all_voices attribute.
+        
+        Returns:
+            Dictionary mapping TTS provider names to their available voices
+        """
+        return self._get_tts_voices()
+    
+    def get(self, provider_name: str) -> Union[List[str], Dict[str, str]]:
+        """
+        Gets all available voices for a specific TTS provider.
+        
+        Args:
+            provider_name: The name of the TTS provider
+            
+        Returns:
+            List or Dictionary of available voices for the provider
+        """
+        all_voices = self._get_tts_voices()
+        return all_voices.get(provider_name, [])
+    
+    def summary(self) -> Dict[str, Any]:
+        """
+        Returns a summary of available TTS providers and voices.
+        
+        Returns:
+            Dictionary with provider and voice counts
+        """
+        provider_voices = self._get_tts_voices()
+        total_providers = len(provider_voices)
+        
+        # Count voices, handling both list and dict formats
+        total_voices = 0
+        provider_voice_counts = {}
+        
+        for provider, voices in provider_voices.items():
+            if isinstance(voices, dict):
+                count = len(voices)
+            elif isinstance(voices, (list, tuple, set)):
+                count = len(voices)
+            else:
+                count = 1
+                
+            total_voices += count
+            provider_voice_counts[provider] = count
+        
+        return {
+            "providers": total_providers,
+            "voices": total_voices,
+            "provider_voice_counts": provider_voice_counts
+        }
+    
+    def _get_tts_voices(self) -> Dict[str, Union[List[str], Dict[str, str]]]:
+        """
+        Internal method to get all available voices from each TTS provider.
+        
+        Returns:
+            Dictionary mapping TTS provider names to their available voices
+        """
+        provider_voices = {}
+        
+        try:
+            # Import the TTS package specifically
+            tts_package = importlib.import_module("webscout.Provider.TTS")
+            
+            # Iterate through TTS modules
+            for _, module_name, _ in pkgutil.iter_modules(tts_package.__path__):
+                try:
+                    module = importlib.import_module(f"webscout.Provider.TTS.{module_name}")
+                    for attr_name in dir(module):
+                        attr = getattr(module, attr_name)
+                        if isinstance(attr, type) and issubclass(attr, TTSProvider) and attr != TTSProvider:
+                            # TTS providers typically use 'all_voices' instead of 'AVAILABLE_MODELS'
+                            if hasattr(attr, 'all_voices'):
+                                voices = attr.all_voices
+                                provider_voices[attr_name] = voices
+                except Exception as e:
+                    pass
+        except Exception as e:
+            pass
+        
+        return provider_voices
+
+# Create singleton instances
+llm = _LLMModels()
+tts = _TTSModels()
+
+# Container class for all model types
+class Models:
+    def __init__(self):
+        self.llm = llm
+        self.tts = tts
+
+# Create a singleton instance
+model = Models()

webscout/optimizers.py

@@ -3,7 +3,7 @@
 import os
 import platform
 import subprocess
-from typing import  Literal, Optional,  Tuple, Callable, Dict, Any
+from typing import Optional
 class Optimizers:
     """
     >>> Optimizers.code("write a hello world")

webscout/prompt_manager.py

@@ -1,17 +1,11 @@
-"""
-HAI's Awesome Prompts! 🔥
-The most fire prompts collection you'll ever see! 💯
-Created by the legendary HAI squad! 👑
-"""
+# -*- coding: utf-8 -*-
 
 import os
 import json
-import logging
 import requests
-from typing import Optional, Dict, Union, List
+from typing import Optional, Dict, Union
 from rich.console import Console
 from rich.table import Table
-from rich.panel import Panel
 from datetime import datetime
 
 console = Console()

webscout/scout/core/scout.py

@@ -1,15 +1,12 @@
 """
 Scout Main Module - HTML Parsing and Traversal
 """
-import sys
 import re
-import warnings
 import json
 import hashlib
 import unicodedata
-import os
 import urllib.parse
-from typing import Union, List, Dict, Optional, Callable, Any, Tuple
+from typing import List, Dict, Optional, Any
 
 from ..parsers import ParserRegistry
 from ..element import Tag, NavigableString

webscout/scout/core/search_result.py

@@ -2,7 +2,7 @@
 Scout Search Result Module
 """
 
-from typing import List, Union, Callable, Any, Dict, Iterator, Set
+from typing import List, Union, Callable, Any, Dict, Iterator
 from ..element import Tag
 from .text_analyzer import ScoutTextAnalyzer
 

webscout/scout/core/text_utils.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Tuple, Set, Optional, Pattern
+from typing import List, Dict, Tuple, Set, Pattern
 import re
 
 

webscout/scout/core.py

@@ -4,19 +4,16 @@ A powerful, flexible, and performant HTML parsing library.
 Enhanced with advanced features and intelligent parsing.
 """
 
-import sys
 import re
-import warnings
 import json
 import hashlib
 import unicodedata
-import os
 import requests
 from markdownify import MarkdownConverter
 import concurrent.futures
 import urllib.parse
-from collections import Counter, defaultdict
-from typing import Union, List, Dict, Optional, Callable, Any, Tuple, Iterator, Set
+from collections import Counter
+from typing import Union, List, Dict, Optional, Callable, Any, Iterator, Set
 
 from .parsers.html_parser import HTMLParser
 from .parsers.lxml_parser import LXMLParser

webscout/scout/element.py

@@ -3,7 +3,7 @@ Scout Element Module - Advanced HTML Element Representation
 """
 
 import re
-from typing import Optional, List, Dict, Union, Any, Callable, Iterable
+from typing import Optional, List, Dict, Union, Any
 
 class NavigableString(str):
     """

webscout/scout/parsers/html_parser.py

@@ -5,7 +5,7 @@ Scout HTML Parser - Advanced HTML Parsing with Python's Built-in Parser
 import html
 import re
 from html.parser import HTMLParser as StdHTMLParser
-from typing import List, Optional, Dict, Any, Union
+from typing import List
 
 from ..element import Tag, NavigableString
 

webscout/scout/utils.py

@@ -2,7 +2,6 @@
 Utility functions - making life easier! 🛠️
 """
 
-import re
 from typing import Union, Optional
 
 def decode_markup(markup: Union[str, bytes], encoding: Optional[str] = None) -> str:

webscout/swiftcli/__init__.py

@@ -30,15 +30,13 @@ For more examples, check out the documentation!
 import importlib
 import os
 import sys
-import json
 import inspect
-from typing import Any, Dict, List, Optional, Type, Union, Callable
+from typing import Any, Dict, List, Optional, Callable
 from functools import wraps
 from pathlib import Path
 from rich.console import Console
 from rich.table import Table
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.theme import Theme
 
 # Console setup
 console = Console()

webscout/tempid.py

@@ -1,6 +1,6 @@
 import aiohttp
 from dataclasses import dataclass
-from typing import ClassVar, NoReturn, List, Dict, Any
+from typing import NoReturn, List, Dict, Any
 import requests
 
 @dataclass

webscout/update_checker.py

@@ -6,9 +6,7 @@ Webscout Update Checker
 'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
 """
 
-import sys
-import os
-from typing import Optional, Tuple, Dict, Any, Literal, Union
+from typing import Optional, Dict, Any, Literal
 
 import requests
 from packaging import version

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "7.5"
+__version__ = "7.7"
 __prog__ = "webscout"

webscout/webscout_search_async.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 import os
 import warnings
 from datetime import datetime, timezone
@@ -26,7 +25,7 @@ from .utils import (
     json_loads,
 )
 
-logger = logging.getLogger("webscout.AsyncWEBS")
+
 
 
 class AsyncWEBS: