webscout 8.3.7__py3-none-any.whl → 2025.10.13__py3-none-any.whl

webscout/litagent/constants.py

@@ -1,60 +1,60 @@
-"""Constants used by the LitAgent module."""
-
-# Browser versions we support
-BROWSERS = {
-    "chrome": (48, 120),
-    "firefox": (48, 121),
-    "safari": (605, 617),
-    "edge": (79, 120),
-    "opera": (48, 104),
-    "brave": (100, 120),
-    "vivaldi": (5, 6)
-}
-
-# OS versions
-OS_VERSIONS = {
-    "windows": ["10.0", "11.0"],
-    "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"],
-    "chrome_os": ["13.0", "14.0", "15.0"]
-}
-
-# Device types
-DEVICES = {
-    "mobile": [
-        "iPhone", "iPad", "Samsung Galaxy", "Google Pixel",
-        "OnePlus", "Xiaomi", "Huawei", "OPPO", "Vivo"
-    ],
-    "desktop": ["Windows PC", "MacBook", "iMac", "Linux Desktop"],
-    "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"
-    ]
+"""Constants used by the LitAgent module."""
+
+# Browser versions we support
+BROWSERS = {
+    "chrome": (48, 120),
+    "firefox": (48, 121),
+    "safari": (605, 617),
+    "edge": (79, 120),
+    "opera": (48, 104),
+    "brave": (100, 120),
+    "vivaldi": (5, 6)
+}
+
+# OS versions
+OS_VERSIONS = {
+    "windows": ["10.0", "11.0"],
+    "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"],
+    "chrome_os": ["13.0", "14.0", "15.0"]
+}
+
+# Device types
+DEVICES = {
+    "mobile": [
+        "iPhone", "iPad", "Samsung Galaxy", "Google Pixel",
+        "OnePlus", "Xiaomi", "Huawei", "OPPO", "Vivo"
+    ],
+    "desktop": ["Windows PC", "MacBook", "iMac", "Linux Desktop"],
+    "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

@@ -1,59 +1,59 @@
-"""
->>> from litprinter import litprint
->>> from litprinter import lit
->>> from litprinter import install, uninstall
->>>
->>> litprint("Hello, world!")
-LIT -> [__main__.py:1] in () >>> Hello, world!
->>>
->>> def my_function():
-...    lit(1, 2, 3)
->>> my_function()
-LIT -> [__main__.py:4] in my_function() >>> 1, 2, 3
->>> install()
->>> ic("This is now the builtins.ic()")
-LIT -> [__main__.py:7] in () >>> This is now the builtins.ic()
->>> uninstall()
-
-This module provides enhanced print and logging functionalities for Python,
-allowing developers to debug their code with style and precision. It
-includes the litprint and lit functions for debugging, log for logging, and
-install/uninstall functions for integration into the builtins module.
-It also handles colorizing output and provides different styles and customizable
-options.
-
-LITPRINTER is inspired by the icecream package and provides similar functionality
-with additional features:
-- Variable inspection with expression display
-- Return value handling for inline usage
-- Support for custom formatters for specific data types
-- Execution context tracking
-- Rich-like colorized output with multiple themes (JARVIS, RICH, MODERN, NEON, CYBERPUNK)
-- Better JSON formatting with indent=2 by default
-- Advanced pretty printing for complex data structures with smart truncation
-- Clickable file paths in supported terminals and editors (VSCode compatible)
-- Enhanced visual formatting with better spacing and separators
-- Special formatters for common types (Exception, bytes, set, frozenset, etc.)
-- Smart object introspection for custom classes
-- Logging capabilities with timestamp and log levels
-"""
-
-# Try to import from the standalone litprinter package first
-# If it's not installed
-try:
-    import litprinter
-    # If standalone package is found, re-export all its components
-    from litprinter import litprint, lit, log, ic, install, uninstall
-    from litprinter import LITPrintDebugger, argumentToString
-    from litprinter import JARVIS, RICH, MODERN, NEON, CYBERPUNK, create_custom_style
-    from litprinter import traceback   
-    # For compatibility with icecream
-    enable = litprinter.enable
-    disable = litprinter.disable
-    
-except ImportError:
-    # Raise a more informative error when litprinter is not installed
-    raise ImportError(
-        "The 'litprinter' package is required but not installed. "
-        "Please install it using: pip install litprinter"
+"""
+>>> from litprinter import litprint
+>>> from litprinter import lit
+>>> from litprinter import install, uninstall
+>>>
+>>> litprint("Hello, world!")
+LIT -> [__main__.py:1] in () >>> Hello, world!
+>>>
+>>> def my_function():
+...    lit(1, 2, 3)
+>>> my_function()
+LIT -> [__main__.py:4] in my_function() >>> 1, 2, 3
+>>> install()
+>>> ic("This is now the builtins.ic()")
+LIT -> [__main__.py:7] in () >>> This is now the builtins.ic()
+>>> uninstall()
+
+This module provides enhanced print and logging functionalities for Python,
+allowing developers to debug their code with style and precision. It
+includes the litprint and lit functions for debugging, log for logging, and
+install/uninstall functions for integration into the builtins module.
+It also handles colorizing output and provides different styles and customizable
+options.
+
+LITPRINTER is inspired by the icecream package and provides similar functionality
+with additional features:
+- Variable inspection with expression display
+- Return value handling for inline usage
+- Support for custom formatters for specific data types
+- Execution context tracking
+- Rich-like colorized output with multiple themes (JARVIS, RICH, MODERN, NEON, CYBERPUNK)
+- Better JSON formatting with indent=2 by default
+- Advanced pretty printing for complex data structures with smart truncation
+- Clickable file paths in supported terminals and editors (VSCode compatible)
+- Enhanced visual formatting with better spacing and separators
+- Special formatters for common types (Exception, bytes, set, frozenset, etc.)
+- Smart object introspection for custom classes
+- Logging capabilities with timestamp and log levels
+"""
+
+# Try to import from the standalone litprinter package first
+# If it's not installed
+try:
+    import litprinter
+    # If standalone package is found, re-export all its components
+    from litprinter import litprint, lit, log, ic, install, uninstall
+    from litprinter import LITPrintDebugger, argumentToString
+    from litprinter import JARVIS, RICH, MODERN, NEON, CYBERPUNK, create_custom_style
+    from litprinter import traceback   
+    # For compatibility with icecream
+    enable = litprinter.enable
+    disable = litprinter.disable
+    
+except ImportError:
+    # Raise a more informative error when litprinter is not installed
+    raise ImportError(
+        "The 'litprinter' package is required but not installed. "
+        "Please install it using: pip install litprinter"
     ) from None

webscout/models.py

@@ -1,181 +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()
+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()