pytrends-modern 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

pytrends_modern/__init__.py

@@ -2,13 +2,15 @@
 pytrends-modern: Modern Google Trends API
 """
 
-__version__ = "1.0.0"
+__version__ = "0.2.0"
 __author__ = "pytrends-modern contributors"
 __license__ = "MIT"
 
 from pytrends_modern.request import TrendReq
 from pytrends_modern.rss import TrendsRSS
 from pytrends_modern.scraper import TrendsScraper
+from pytrends_modern.browser_config_camoufox import BrowserConfig
+from pytrends_modern import camoufox_setup
 from pytrends_modern.exceptions import (
     TooManyRequestsError,
     ResponseError,
@@ -21,6 +23,8 @@ __all__ = [
     "TrendReq",
     "TrendsRSS",
     "TrendsScraper",
+    "BrowserConfig",
+    "camoufox_setup",
     "TooManyRequestsError",
     "ResponseError",
     "InvalidParameterError",

pytrends_modern/browser_config.py

@@ -0,0 +1,94 @@
+"""Browser configuration for DrissionPage automation."""
+
+from typing import Optional
+
+
+class BrowserConfig:
+    """Configuration for DrissionPage browser automation.
+    
+    When enabled, TrendReq will use DrissionPage to capture network traffic
+    from trends.google.com instead of making direct API calls.
+    
+    ⚠️ LIMITATIONS when using BrowserConfig:
+    - Only 1 keyword supported (no comparison)
+    - Only 'today 1-m' timeframe supported
+    - Only WORLDWIDE geo supported (no geo filtering)
+    - Requires Chrome/Chromium browser installed
+    
+    Args:
+        browser_path: Path to Chrome/Chromium executable.
+                     Defaults: '/usr/bin/chromium' or '/usr/bin/chrome'
+        port: Browser remote debugging port (default: 9222)
+        headless: Run browser in headless mode (default: True)
+        proxy: Proxy server URL (e.g., 'http://proxy.com:8080')
+        proxy_username: Proxy username (for authenticated proxies)
+        proxy_password: Proxy password (for authenticated proxies)
+        user_data_dir: Browser profile directory to persist login session.
+                      If not provided, creates temp directory (won't persist)
+    
+    Example:
+        >>> from pytrends_modern import TrendReq, BrowserConfig
+        >>> # Without auth - manual login required once
+        >>> config = BrowserConfig(
+        ...     browser_path='/usr/bin/chromium',
+        ...     user_data_dir='~/.config/chromium-pytrends'
+        ... )
+        >>> # With proxy auth
+        >>> config = BrowserConfig(
+        ...     browser_path='/usr/bin/chromium',
+        ...     proxy='153.80.44.3:64804',
+        ...     proxy_username='user',
+        ...     proxy_password='pass',
+        ...     user_data_dir='~/.config/chromium-pytrends'
+        ... )
+        >>> pytrends = TrendReq(browser_config=config)
+        >>> pytrends.build_payload(['Python'])  # Only 1 keyword!
+        >>> df = pytrends.interest_over_time()
+    """
+    
+    def __init__(
+        self,
+        browser_path: Optional[str] = None,
+        port: int = 9222,
+        headless: bool = True,
+        proxy: Optional[str] = None,
+        proxy_username: Optional[str] = None,
+        proxy_password: Optional[str] = None,
+        user_data_dir: Optional[str] = None
+    ):
+        self.browser_path = browser_path or self._get_default_browser_path()
+        self.port = port
+        self.headless = headless
+        self.proxy = proxy
+        self.proxy_username = proxy_username
+        self.proxy_password = proxy_password
+        self.user_data_dir = user_data_dir
+    
+    @staticmethod
+    def _get_default_browser_path() -> str:
+        """Get default browser path based on common locations."""
+        import os
+        
+        # Common Chrome/Chromium paths
+        paths = [
+            '/usr/bin/chromium',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/chrome',
+            '/usr/bin/google-chrome',
+            '/snap/bin/chromium',
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        ]
+        
+        for path in paths:
+            if os.path.exists(path):
+                return path
+        
+        # Default fallback
+        return '/usr/bin/chromium'
+    
+    def __repr__(self) -> str:
+        return (
+            f"BrowserConfig(browser_path='{self.browser_path}', "
+            f"port={self.port}, headless={self.headless}, proxy={self.proxy})"
+        )

pytrends_modern/browser_config_camoufox.py

@@ -0,0 +1,67 @@
+"""Browser configuration for Camoufox automation"""
+
+from typing import Optional
+import os as os_module
+
+
+class BrowserConfig:
+    """Configuration for Camoufox browser automation.
+    
+    Uses Camoufox (Playwright Firefox) with advanced fingerprinting and
+    anti-detection to bypass Google's bot detection.
+    
+    ⚠️ LIMITATIONS:
+    - Only 1 keyword supported (no comparison)
+    - Only 'today 1-m' timeframe supported
+    - Only WORLDWIDE geo supported (no geo filtering)
+    - Requires Google account login (first run)
+    
+    Args:
+        headless: Run browser in headless mode (default: False)
+                 Set to 'virtual' on Linux to use Xvfb
+        proxy_server: Proxy server URL (e.g., 'http://proxy.com:8080')
+        proxy_username: Proxy username (for authenticated proxies)
+        proxy_password: Proxy password (for authenticated proxies)
+        user_data_dir: Browser profile directory to persist login session.
+                      Default: ~/.config/camoufox-pytrends
+        humanize: Enable human-like cursor movement (default: True)
+        os: Operating system for fingerprint ('windows', 'macos', 'linux')
+        geoip: Auto-detect geolocation from proxy IP (default: True if proxy)
+    
+    Example:
+        >>> from pytrends_modern import TrendReq, BrowserConfig
+        >>> # Simple usage (logs in once, saves session)
+        >>> config = BrowserConfig()
+        >>> pytrends = TrendReq(browser_config=config)
+        >>> pytrends.build_payload(['Python'])
+        >>> df = pytrends.interest_over_time()
+        >>>
+        >>> # With proxy
+        >>> config = BrowserConfig(
+        ...     proxy_server='http://proxy.com:8080',
+        ...     proxy_username='user',
+        ...     proxy_password='pass',
+        ...     geoip=True
+        ... )
+    """
+    
+    def __init__(
+        self,
+        headless: bool = False,
+        proxy_server: Optional[str] = None,
+        proxy_username: Optional[str] = None,
+        proxy_password: Optional[str] = None,
+        user_data_dir: Optional[str] = None,
+        humanize: bool = True,
+        os: str = 'linux',
+        geoip: bool = True,
+    ):
+        self.headless = headless
+        self.proxy_server = proxy_server
+        self.proxy_username = proxy_username
+        self.proxy_password = proxy_password
+        self.user_data_dir = user_data_dir or os_module.path.expanduser('~/.config/camoufox-pytrends-profile')
+        self.humanize = humanize
+        self.os = os
+        self.geoip = geoip if proxy_server else False
+

pytrends_modern/camoufox_setup.py

@@ -0,0 +1,300 @@
+"""
+Camoufox setup and configuration helper for pytrends-modern
+
+This module helps users set up their Google account login for browser mode.
+"""
+
+import os
+from typing import Optional
+
+
+def get_default_profile_dir() -> str:
+    """Get the default Camoufox profile directory"""
+    return os.path.expanduser('~/.config/camoufox-pytrends-profile')
+
+
+def is_profile_configured(profile_dir: Optional[str] = None) -> bool:
+    """
+    Check if Camoufox profile is configured (has Google login)
+    
+    Args:
+        profile_dir: Custom profile directory, or None for default
+        
+    Returns:
+        True if profile exists and appears configured
+    """
+    if profile_dir is None:
+        profile_dir = get_default_profile_dir()
+    else:
+        profile_dir = os.path.expanduser(profile_dir)
+    
+    # Check if profile directory exists and has content
+    if not os.path.exists(profile_dir):
+        return False
+    
+    # Check if it has Firefox profile structure (indicates browser has been used)
+    # Camoufox uses Firefox, so we check for common Firefox profile files
+    profile_indicators = [
+        'prefs.js',
+        'cookies.sqlite',
+        'storage',
+    ]
+    
+    for indicator in profile_indicators:
+        if os.path.exists(os.path.join(profile_dir, indicator)):
+            return True
+    
+    return False
+
+
+def setup_profile(profile_dir: Optional[str] = None, headless: bool = False) -> bool:
+    """
+    Interactive setup: Open browser for user to log in to Google
+    
+    Args:
+        profile_dir: Custom profile directory, or None for default
+        headless: Run in headless mode (not recommended for first setup)
+        
+    Returns:
+        True if setup completed successfully
+        
+    Raises:
+        ImportError: If Camoufox is not installed
+    """
+    try:
+        from camoufox.sync_api import Camoufox
+    except ImportError:
+        raise ImportError(
+            "Camoufox is required for browser mode. "
+            "Install with: pip install pytrends-modern[browser]"
+        )
+    
+    if profile_dir is None:
+        profile_dir = get_default_profile_dir()
+    else:
+        profile_dir = os.path.expanduser(profile_dir)
+    
+    print("=" * 70)
+    print("🔧 Camoufox Profile Setup for pytrends-modern")
+    print("=" * 70)
+    print(f"\n📁 Profile directory: {profile_dir}")
+    
+    if is_profile_configured(profile_dir):
+        print("✓ Profile already exists")
+        response = input("\nReconfigure profile? This will open the browser again (y/N): ")
+        if response.lower() != 'y':
+            print("Setup cancelled.")
+            return False
+    
+    print("\n📖 Instructions:")
+    print("1. Browser will open to Google Trends")
+    print("2. Log in to your Google account")
+    print("3. Once logged in and page loads, press Enter here")
+    print("4. Your login will be saved for future use")
+    print("\n⚠️  IMPORTANT: Browser mode has limitations:")
+    print("   - Only 1 keyword at a time (no comparisons)")
+    print("   - Only 'today 1-m' timeframe")
+    print("   - Only WORLDWIDE region")
+    print()
+    
+    input("Press Enter to open browser...")
+    
+    try:
+        with Camoufox(
+            persistent_context=True,
+            user_data_dir=profile_dir,
+            headless=headless,
+            humanize=True,
+            os='linux',
+            geoip=True,
+        ) as context:
+            page = context.pages[0] if context.pages else context.new_page()
+            
+            print("\n🌐 Opening Google Trends...")
+            print("   Please log in to your Google account")
+            
+            # Navigate to Google Trends
+            page.goto(
+                "https://trends.google.com/trends/explore?q=Python&hl=en-GB",
+                wait_until='networkidle',
+                timeout=60000
+            )
+            
+            title = page.title()
+            if "429" in title or "error" in title.lower():
+                print(f"\n⚠️  Page title: {title}")
+                print("   You may need to log in or solve a CAPTCHA")
+            else:
+                print(f"✓ Page loaded: {title}")
+            
+            print("\n📋 Please:")
+            print("   1. Log in to Google if not already logged in")
+            print("   2. Make sure the page loads correctly")
+            print("   3. Then come back here and press Enter")
+            
+            input("\nPress Enter when done (browser will close)...")
+            
+        # Verify profile was created
+        if is_profile_configured(profile_dir):
+            print("\n✅ SUCCESS! Profile configured successfully")
+            print(f"📁 Profile saved to: {profile_dir}")
+            print("\n💡 You can now use pytrends-modern with browser mode:")
+            print("   from pytrends_modern import TrendReq, BrowserConfig")
+            print("   config = BrowserConfig()")
+            print("   pytrends = TrendReq(browser_config=config)")
+            return True
+        else:
+            print("\n⚠️  Warning: Profile directory exists but may not be fully configured")
+            print("   Try running setup again or check if browser saved data")
+            return False
+            
+    except Exception as e:
+        print(f"\n❌ Error during setup: {e}")
+        return False
+
+
+def export_profile(source_dir: Optional[str] = None, dest_path: str = "./camoufox-profile.tar.gz") -> bool:
+    """
+    Export profile to a tar.gz file for portability (Docker, other machines, etc.)
+    
+    Args:
+        source_dir: Source profile directory, or None for default
+        dest_path: Destination file path for the exported profile
+        
+    Returns:
+        True if export successful
+    """
+    import tarfile
+    
+    if source_dir is None:
+        source_dir = get_default_profile_dir()
+    else:
+        source_dir = os.path.expanduser(source_dir)
+    
+    if not is_profile_configured(source_dir):
+        print(f"❌ Profile not configured at: {source_dir}")
+        return False
+    
+    try:
+        print(f"📦 Exporting profile from: {source_dir}")
+        print(f"📁 To: {dest_path}")
+        
+        with tarfile.open(dest_path, "w:gz") as tar:
+            tar.add(source_dir, arcname=os.path.basename(source_dir))
+        
+        print(f"✅ Profile exported successfully!")
+        print(f"📊 File size: {os.path.getsize(dest_path) / 1024 / 1024:.2f} MB")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Export failed: {e}")
+        return False
+
+
+def import_profile(source_path: str, dest_dir: Optional[str] = None) -> bool:
+    """
+    Import profile from a tar.gz file (for Docker, other machines, etc.)
+    
+    Args:
+        source_path: Source tar.gz file path
+        dest_dir: Destination profile directory, or None for default
+        
+    Returns:
+        True if import successful
+    """
+    import tarfile
+    
+    if dest_dir is None:
+        dest_dir = get_default_profile_dir()
+    else:
+        dest_dir = os.path.expanduser(dest_dir)
+    
+    if not os.path.exists(source_path):
+        print(f"❌ Source file not found: {source_path}")
+        return False
+    
+    try:
+        print(f"📦 Importing profile from: {source_path}")
+        print(f"📁 To: {dest_dir}")
+        
+        # Create parent directory if needed
+        os.makedirs(os.path.dirname(dest_dir), exist_ok=True)
+        
+        with tarfile.open(source_path, "r:gz") as tar:
+            tar.extractall(path=os.path.dirname(dest_dir))
+        
+        if is_profile_configured(dest_dir):
+            print(f"✅ Profile imported successfully!")
+            return True
+        else:
+            print(f"⚠️  Profile imported but may not be fully configured")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Import failed: {e}")
+        return False
+
+
+def print_profile_status(profile_dir: Optional[str] = None):
+    """Print current profile configuration status"""
+    if profile_dir is None:
+        profile_dir = get_default_profile_dir()
+    else:
+        profile_dir = os.path.expanduser(profile_dir)
+    
+    print("=" * 70)
+    print("🔍 Camoufox Profile Status")
+    print("=" * 70)
+    print(f"\n📁 Profile directory: {profile_dir}")
+    
+    if is_profile_configured(profile_dir):
+        print("✅ Status: Configured")
+        print("\n💡 Profile is ready to use with browser mode")
+        print("\n📦 To use in Docker/other machines:")
+        print("   1. Export: from pytrends_modern.camoufox_setup import export_profile")
+        print("              export_profile(dest_path='profile.tar.gz')")
+        print("   2. Copy profile.tar.gz to target machine/container")
+        print("   3. Import: from pytrends_modern.camoufox_setup import import_profile")
+        print("              import_profile('profile.tar.gz')")
+    else:
+        print("❌ Status: Not configured")
+        print("\n⚠️  You need to run setup before using browser mode:")
+        print("   from pytrends_modern.camoufox_setup import setup_profile")
+        print("   setup_profile()")
+        print("\n   Or use the CLI:")
+        print("   python -m pytrends_modern.camoufox_setup")
+    
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    """Run setup when called as a module"""
+    import sys
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "status":
+            print_profile_status()
+        elif command == "export":
+            dest = sys.argv[2] if len(sys.argv) > 2 else "./camoufox-profile.tar.gz"
+            success = export_profile(dest_path=dest)
+            sys.exit(0 if success else 1)
+        elif command == "import":
+            if len(sys.argv) < 3:
+                print("❌ Usage: python -m pytrends_modern.camoufox_setup import <source.tar.gz>")
+                sys.exit(1)
+            source = sys.argv[2]
+            success = import_profile(source)
+            sys.exit(0 if success else 1)
+        else:
+            print(f"❌ Unknown command: {command}")
+            print("\nUsage:")
+            print("  python -m pytrends_modern.camoufox_setup          # Run setup")
+            print("  python -m pytrends_modern.camoufox_setup status   # Check status")
+            print("  python -m pytrends_modern.camoufox_setup export [path]  # Export profile")
+            print("  python -m pytrends_modern.camoufox_setup import <path>  # Import profile")
+            sys.exit(1)
+    else:
+        success = setup_profile()
+        sys.exit(0 if success else 1)

pytrends_modern/proxy_extension.py

@@ -0,0 +1,78 @@
+"""
+Proxy extension generator for Chrome/Chromium with automatic authentication
+Creates a simple extension that handles proxy auth without any UI
+"""
+
+import os
+import tempfile
+import json
+
+
+def create_proxy_extension(username: str, password: str, host: str, port: int) -> str:
+    """
+    Create a Chrome extension that automatically handles proxy authentication
+    No UI, no dialogs - completely automatic
+    
+    Args:
+        username: Proxy username
+        password: Proxy password
+        host: Proxy host/IP
+        port: Proxy port
+    
+    Returns:
+        Path to the extension folder (DrissionPage needs folder not ZIP)
+    """
+    
+    # Create temp directory for extension
+    extension_dir = tempfile.mkdtemp(prefix='proxy_auth_')
+    
+    # Manifest v3 - simple and clean
+    manifest = {
+        "manifest_version": 3,
+        "name": "Auto Proxy Auth",
+        "version": "1.0",
+        "description": "Automatic proxy authentication",
+        "permissions": [
+            "webRequest",
+            "webRequestAuthProvider"
+        ],
+        "host_permissions": [
+            "<all_urls>"
+        ],
+        "background": {
+            "service_worker": "background.js"
+        }
+    }
+    
+    # Background script - handles auth automatically
+    background_js = f"""
+// Automatic proxy authentication - no UI
+chrome.webRequest.onAuthRequired.addListener(
+    function(details) {{
+        console.log('[Proxy Auth] Providing credentials for:', details.url);
+        return {{
+            authCredentials: {{
+                username: "{username}",
+                password: "{password}"
+            }}
+        }};
+    }},
+    {{urls: ["<all_urls>"]}},
+    ["blocking"]
+);
+
+console.log('[Proxy Auth] Extension loaded - auth will be automatic');
+"""
+    
+    # Write manifest
+    with open(os.path.join(extension_dir, 'manifest.json'), 'w') as f:
+        json.dump(manifest, f, indent=2)
+    
+    # Write background script
+    with open(os.path.join(extension_dir, 'background.js'), 'w') as f:
+        f.write(background_js)
+    
+    print(f"[Proxy Extension] Created at: {extension_dir}")
+    print(f"[Proxy Extension] Username: {username}, Host: {host}:{port}")
+    
+    return extension_dir

pytrends_modern/request.py

@@ -15,6 +15,7 @@ from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
 
 from pytrends_modern import exceptions
+from pytrends_modern.browser_config_camoufox import BrowserConfig
 from pytrends_modern.config import (
     BASE_TRENDS_URL,
     CATEGORIES_URL,
@@ -72,6 +73,7 @@ class TrendReq:
         backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
         requests_args: Optional[Dict[str, Any]] = None,
         rotate_user_agent: bool = True,
+        browser_config: Optional[BrowserConfig] = None,
     ):
         """
         Initialize Google Trends API client
@@ -86,7 +88,36 @@ class TrendReq:
             backoff_factor: Backoff factor for exponential backoff
             requests_args: Additional arguments to pass to requests
             rotate_user_agent: Whether to rotate user agents
+            browser_config: DrissionPage browser configuration (experimental)
+                           
+                           ⚠️ LIMITATIONS when using browser_config:
+                           - Only 1 keyword supported (no comparison)
+                           - Only 'today 1-m' timeframe supported
+                           - Only WORLDWIDE geo supported (no geo filtering)
+                           - Requires Chrome/Chromium browser installed
         """
+        # Browser mode initialization
+        self.browser_config = browser_config
+        self.browser = None
+        self.browser_context = None
+        self.browser_page = None
+        self.browser_mode = browser_config is not None
+        self.browser_responses_cache = {}  # Cache for captured API responses
+        
+        if self.browser_mode:
+            import warnings
+            warnings.warn(
+                "⚠️  Camoufox browser mode is EXPERIMENTAL and has limitations:\n"
+                "   - Only 1 keyword supported (no keyword comparison)\n"
+                "   - Only 'today 1-m' timeframe supported\n"
+                "   - Only WORLDWIDE geo supported\n"
+                "   - Requires Google account login (first run)\n"
+                "   - Login session is saved for future runs",
+                UserWarning,
+                stacklevel=2
+            )
+            self._init_camoufox()
+        
         # Rate limit message from Google
         self.google_rl = "You have reached your quota limit. Please try again later."
 
@@ -112,8 +143,11 @@ class TrendReq:
                 # Store dict format in requests_args
                 self.requests_args["proxies"] = proxies
 
-        # Get initial cookies
-        self.cookies = self._get_google_cookie()
+        # Get initial cookies (skip in browser mode)
+        if not self.browser_mode:
+            self.cookies = self._get_google_cookie()
+        else:
+            self.cookies = {}
 
         # Initialize widget payloads
         self.token_payload: Dict[str, Any] = {}
@@ -127,10 +161,330 @@ class TrendReq:
         if self.rotate_user_agent:
             self.headers["User-Agent"] = random.choice(USER_AGENTS)
         self.headers.update(self.requests_args.pop("headers", {}))
+    
+    def __del__(self):
+        """Cleanup browser on object deletion"""
+        self._close_browser()
 
     def _get_user_agent(self) -> str:
         """Get a random user agent"""
         return random.choice(USER_AGENTS) if self.rotate_user_agent else USER_AGENTS[0]
+    
+    def _init_camoufox(self) -> None:
+        """Initialize Camoufox browser with persistent context"""
+        try:
+            from camoufox.sync_api import Camoufox
+        except ImportError:
+            raise ImportError(
+                "Camoufox is required for browser mode. "
+                "Install with: pip install pytrends-modern[browser]"
+            )
+        
+        # Prepare browser options
+        import os
+        user_data_dir = os.path.expanduser(
+            self.browser_config.user_data_dir or "~/.config/camoufox-pytrends-profile"
+        )
+        
+        # Check if profile is configured (has Google login)
+        from pytrends_modern.camoufox_setup import is_profile_configured
+        if not is_profile_configured(user_data_dir):
+            raise exceptions.BrowserError(
+                f"Camoufox profile not configured at: {user_data_dir}\n"
+                "You must set up your Google account login first:\n\n"
+                "  from pytrends_modern.camoufox_setup import setup_profile\n"
+                "  setup_profile()\n\n"
+                "Or run from command line:\n"
+                "  python -m pytrends_modern.camoufox_setup\n\n"
+                "This will open a browser for you to log in to Google."
+            )
+        
+        # Proxy configuration (if provided)
+        proxy_config = None
+        if self.browser_config.proxy_server:
+            proxy_config = {
+                "server": self.browser_config.proxy_server,
+            }
+            if self.browser_config.proxy_username:
+                proxy_config["username"] = self.browser_config.proxy_username
+            if self.browser_config.proxy_password:
+                proxy_config["password"] = self.browser_config.proxy_password
+        
+        # Initialize Camoufox with persistent context
+        try:
+            # Camoufox() returns a context manager, we need to use __enter__() to get the context
+            camoufox_manager = Camoufox(
+                persistent_context=True,
+                user_data_dir=user_data_dir,
+                headless=self.browser_config.headless,
+                humanize=self.browser_config.humanize if hasattr(self.browser_config, 'humanize') else True,
+                os=self.browser_config.os if hasattr(self.browser_config, 'os') else 'linux',
+                geoip=self.browser_config.geoip if hasattr(self.browser_config, 'geoip') else True,
+                proxy=proxy_config
+            )
+            
+            # Enter the context manager to get the browser context
+            self.browser = camoufox_manager  # Store manager for cleanup
+            self.browser_context = camoufox_manager.__enter__()
+            
+            # Use existing page if available (avoid opening 2 tabs)
+            if self.browser_context.pages:
+                self.browser_page = self.browser_context.pages[0]
+            else:
+                self.browser_page = self.browser_context.new_page()
+            
+            # Set up network interception
+            self.browser_page.on("response", self._handle_network_response)
+            
+        except Exception as e:
+            raise exceptions.BrowserError(f"Failed to initialize Camoufox: {e}")
+    
+    def _close_browser(self) -> None:
+        """Close browser if open"""
+        if self.browser:
+            try:
+                # Exit the context manager
+                self.browser.__exit__(None, None, None)
+            except Exception:
+                pass
+            self.browser = None
+            self.browser_context = None
+            self.browser_page = None
+    
+    def _handle_network_response(self, response) -> None:
+        """
+        Handle network responses and cache Google Trends API data
+        
+        Args:
+            response: Playwright response object
+        """
+        url = response.url
+        
+        # Only process Google Trends API responses
+        if '/trends/api/widgetdata/' not in url:
+            return
+        
+        try:
+            # Get response body
+            body = response.body()
+            
+            # Parse the response (remove Google's JSONP prefix - exactly 5 bytes)
+            if body.startswith(b")]}'\n"):
+                body = body[5:]
+            elif body.startswith(b")]}'"):
+                body = body[5:]
+            
+            data = json.loads(body)
+            
+            # Cache by URL pattern
+            if '/widgetdata/multiline' in url:
+                self.browser_responses_cache['interest_over_time'] = data
+            elif '/widgetdata/comparedgeo' in url:
+                self.browser_responses_cache['interest_by_region'] = data
+            elif '/widgetdata/relatedsearches' in url:
+                # keywordType is URL-encoded inside the req parameter
+                import urllib.parse
+                decoded_url = urllib.parse.unquote(url)
+                if 'keywordType":"ENTITY' in decoded_url:
+                    self.browser_responses_cache['related_topics'] = data
+                elif 'keywordType":"QUERY' in decoded_url:
+                    self.browser_responses_cache['related_queries'] = data
+                    
+        except Exception:
+            pass  # Silently ignore parsing errors
+    
+    def _capture_all_api_responses(self, keyword: str) -> None:
+        """
+        Navigate once and capture ALL API responses via network interception
+        
+        Args:
+            keyword: Search keyword to use
+        """
+        if not self.browser_page:
+            raise exceptions.BrowserError("Browser not initialized")
+        
+        # Clear cache
+        self.browser_responses_cache.clear()
+        
+        # Build URL
+        import urllib.parse
+        encoded_keyword = urllib.parse.quote(keyword)
+        url = f"https://trends.google.com/trends/explore?date=today%201-m&q={encoded_keyword}&hl=en-GB"
+        
+        try:
+            # Navigate and wait for network idle
+            self.browser_page.goto(url, wait_until='networkidle', timeout=60000)
+            
+            # Give extra time for any delayed API calls
+            import time
+            time.sleep(2)
+            
+        except Exception as e:
+            raise exceptions.BrowserError(f"Failed to navigate to Google Trends: {e}")
+    
+    def _parse_api_response(self, response_text: str) -> Dict:
+        """
+        Parse API response from Google Trends
+        
+        Google's API responses may contain garbage prefix: ")]}',\n"
+        
+        Args:
+            response_text: Raw response text
+            
+        Returns:
+            Parsed JSON data
+        """
+        # Remove garbage prefix if present
+        if response_text.startswith(")]}',\n"):
+            response_text = response_text[6:]
+        elif response_text.startswith(")]}',"):
+            response_text = response_text[5:]
+        elif response_text.startswith(")]},"):
+            response_text = response_text[5:]
+        elif response_text.startswith(")]}'"):
+            response_text = response_text[4:]
+        
+        try:
+            return json.loads(response_text)
+        except json.JSONDecodeError as e:
+            raise exceptions.ResponseError(f"Failed to parse API response: {e}")
+    
+    def _parse_multiline_response(self, data: Dict) -> pd.DataFrame:
+        """
+        Parse multiline API response (interest over time)
+        
+        Args:
+            data: Parsed JSON response from multiline API
+            
+        Returns:
+            DataFrame with date index and keyword columns
+        """
+        try:
+            timeline_data = data.get('default', {}).get('timelineData', [])
+            
+            if not timeline_data:
+                return pd.DataFrame()
+            
+            df = pd.DataFrame(timeline_data)
+            
+            # Convert timestamps to datetime
+            df["date"] = pd.to_datetime(df["time"].astype("float64"), unit="s")
+            df = df.set_index("date").sort_index()
+            
+            # Parse values
+            result_df = df["value"].apply(
+                lambda x: pd.Series(str(x).replace("[", "").replace("]", "").split(","))
+            )
+            
+            # Name columns with keywords
+            for idx, kw in enumerate(self.kw_list):
+                result_df.insert(len(result_df.columns), kw, result_df[idx].astype("int"))
+                del result_df[idx]
+            
+            # Add isPartial column
+            if "isPartial" in df:
+                df["isPartial"] = df["isPartial"].where(df["isPartial"].notna(), False)
+                is_partial_df = df["isPartial"].apply(
+                    lambda x: pd.Series(str(x).replace("[", "").replace("]", "").split(","))
+                )
+                is_partial_df.columns = ["isPartial"]
+                is_partial_df["isPartial"] = is_partial_df["isPartial"] == "True"
+                final_df = pd.concat([result_df, is_partial_df], axis=1)
+            else:
+                final_df = result_df
+                final_df["isPartial"] = False
+            
+            return final_df
+            
+        except Exception as e:
+            raise exceptions.ResponseError(f"Failed to parse multiline response: {e}")
+    
+    def _parse_comparedgeo_response(self, data: Dict, inc_geo_code: bool = False) -> pd.DataFrame:
+        """
+        Parse comparedgeo API response (interest by region)
+        
+        Args:
+            data: Parsed JSON response from comparedgeo API
+            inc_geo_code: Include geographic codes in output
+            
+        Returns:
+            DataFrame with geographic distribution
+        """
+        try:
+            geo_data = data.get('default', {}).get('geoMapData', [])
+            
+            if not geo_data:
+                return pd.DataFrame()
+            
+            df = pd.DataFrame(geo_data)
+            
+            # Determine geo column name
+            geo_column = "geoCode" if "geoCode" in df.columns else "coordinates"
+            columns = ["geoName", geo_column, "value"]
+            df = df[columns].set_index("geoName").sort_index()
+            
+            # Parse values
+            result_df = df["value"].apply(
+                lambda x: pd.Series(str(x).replace("[", "").replace("]", "").split(","))
+            )
+            
+            # Name columns with keywords
+            for idx, kw in enumerate(self.kw_list):
+                result_df.insert(len(result_df.columns), kw, result_df[idx].astype("int"))
+                del result_df[idx]
+            
+            # Add geo code if requested
+            if inc_geo_code and geo_column in df.columns:
+                result_df[geo_column] = df[geo_column]
+            
+            return result_df
+            
+        except Exception as e:
+            raise exceptions.ResponseError(f"Failed to parse comparedgeo response: {e}")
+    
+    def _parse_relatedsearches_response(self, data: Dict) -> Dict[str, Optional[pd.DataFrame]]:
+        """
+        Parse relatedsearches API response (related queries or topics)
+        
+        Args:
+            data: Parsed JSON response from relatedsearches API
+            
+        Returns:
+            Dictionary with 'top' and 'rising' DataFrames
+        """
+        try:
+            ranked_list = data.get('default', {}).get('rankedList', [])
+            
+            # Parse top
+            try:
+                top_data = ranked_list[0]['rankedKeyword']
+                if 'topic' in str(top_data[0]) if top_data else False:
+                    # Topics format
+                    df_top = pd.json_normalize(top_data, sep="_")
+                else:
+                    # Queries format
+                    df_top = pd.DataFrame(top_data)
+                    df_top = df_top[["query", "value"]] if "query" in df_top.columns else df_top
+            except (KeyError, IndexError):
+                df_top = None
+            
+            # Parse rising
+            try:
+                rising_data = ranked_list[1]['rankedKeyword']
+                if 'topic' in str(rising_data[0]) if rising_data else False:
+                    # Topics format
+                    df_rising = pd.json_normalize(rising_data, sep="_")
+                else:
+                    # Queries format
+                    df_rising = pd.DataFrame(rising_data)
+                    df_rising = df_rising[["query", "value"]] if "query" in df_rising.columns else df_rising
+            except (KeyError, IndexError):
+                df_rising = None
+            
+            return {"top": df_top, "rising": df_rising}
+            
+        except Exception as e:
+            raise exceptions.ResponseError(f"Failed to parse relatedsearches response: {e}")
 
     def _get_google_cookie(self) -> Dict[str, str]:
         """
@@ -334,8 +688,9 @@ class TrendReq:
         # Convert req to JSON string (required by Google's API)
         self.token_payload["req"] = json.dumps(self.token_payload["req"])
 
-        # Get tokens from Google
-        self._get_tokens()
+        # Get tokens from Google (skip in browser mode)
+        if not self.browser_mode:
+            self._get_tokens()
 
     def _get_tokens(self) -> None:
         """
@@ -384,6 +739,35 @@ class TrendReq:
             >>> df = pytrends.interest_over_time()
             >>> print(df.head())
         """
+        # Browser mode: capture multiline API response
+        if self.browser_mode:
+            if len(self.kw_list) != 1:
+                raise exceptions.InvalidParameterError(
+                    "Browser mode only supports 1 keyword. You provided: "
+                    + str(len(self.kw_list))
+                )
+            
+            keyword = self.kw_list[0]
+            
+            # Capture all responses if not already cached
+            if not self.browser_responses_cache:
+                self._capture_all_api_responses(keyword)
+            
+            # Get cached response
+            response_data = self.browser_responses_cache.get('interest_over_time')
+            
+            if not response_data:
+                # Try one more navigation if cache is empty
+                self._capture_all_api_responses(keyword)
+                response_data = self.browser_responses_cache.get('interest_over_time')
+                
+            if not response_data:
+                raise exceptions.ResponseError("Failed to capture interest_over_time API response")
+            
+            # Parse browser response to DataFrame
+            return self._parse_multiline_response(response_data)
+        
+        # Standard mode: use widgets
         if not self.interest_over_time_widget:
             raise exceptions.ResponseError(
                 "No interest over time widget available. Call build_payload() first."
@@ -469,6 +853,28 @@ class TrendReq:
             >>> df = pytrends.interest_by_region(resolution='REGION')
             >>> print(df.head())
         """
+        # Browser mode: capture comparedgeo API response
+        if self.browser_mode:
+            if len(self.kw_list) != 1:
+                raise exceptions.InvalidParameterError(
+                    "Browser mode only supports 1 keyword"
+                )
+            
+            keyword = self.kw_list[0]
+            
+            # Capture all responses if not already cached
+            if not self.browser_responses_cache:
+                self._capture_all_api_responses(keyword)
+            
+            # Get cached response
+            response_data = self.browser_responses_cache.get('interest_by_region')
+            
+            if not response_data:
+                raise exceptions.ResponseError("Failed to capture interest_by_region API response")
+            
+            return self._parse_comparedgeo_response(response_data, inc_geo_code)
+        
+        # Standard mode
         if not self.interest_by_region_widget:
             raise exceptions.ResponseError(
                 "No interest by region widget available. Call build_payload() first."
@@ -536,6 +942,28 @@ class TrendReq:
             >>> topics = pytrends.related_topics()
             >>> print(topics['Python']['top'].head())
         """
+        # Browser mode: capture relatedsearches ENTITY API response
+        if self.browser_mode:
+            if len(self.kw_list) != 1:
+                raise exceptions.InvalidParameterError(
+                    "Browser mode only supports 1 keyword"
+                )
+            
+            keyword = self.kw_list[0]
+            
+            # Capture all responses if not already cached
+            if not self.browser_responses_cache:
+                self._capture_all_api_responses(keyword)
+            
+            # Get cached response
+            response_data = self.browser_responses_cache.get('related_topics')
+            
+            if not response_data:
+                raise exceptions.ResponseError("Failed to capture related_topics API response")
+            
+            return {keyword: self._parse_relatedsearches_response(response_data)}
+        
+        # Standard mode
         if not self.related_topics_widget_list:
             raise exceptions.ResponseError(
                 "No related topics widgets available. Call build_payload() first."
@@ -599,6 +1027,28 @@ class TrendReq:
             >>> queries = pytrends.related_queries()
             >>> print(queries['Python']['top'].head())
         """
+        # Browser mode: capture relatedsearches QUERY API response
+        if self.browser_mode:
+            if len(self.kw_list) != 1:
+                raise exceptions.InvalidParameterError(
+                    "Browser mode only supports 1 keyword"
+                )
+            
+            keyword = self.kw_list[0]
+            
+            # Capture all responses if not already cached
+            if not self.browser_responses_cache:
+                self._capture_all_api_responses(keyword)
+            
+            # Get cached response
+            response_data = self.browser_responses_cache.get('related_queries')
+            
+            if not response_data:
+                raise exceptions.ResponseError("Failed to capture related_queries API response")
+            
+            return {keyword: self._parse_relatedsearches_response(response_data)}
+        
+        # Standard mode
         if not self.related_queries_widget_list:
             raise exceptions.ResponseError(
                 "No related queries widgets available. Call build_payload() first."

{pytrends_modern-0.1.2.dist-info → pytrends_modern-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pytrends-modern
-Version: 0.1.2
-Summary: Modern Google Trends API - Combining the best of pytrends, with RSS feeds, Selenium scraping, and enhanced features
+Version: 0.2.0
+Summary: Modern Google Trends API - Combining the best of pytrends, with RSS feeds, Selenium scraping, DrissionPage browser automation, and enhanced features
 Author: pytrends-modern contributors
 License: MIT
 Project-URL: Homepage, https://github.com/yiromo/pytrends-modern
@@ -28,6 +28,9 @@ Requires-Dist: lxml>=4.9.0
 Provides-Extra: selenium
 Requires-Dist: selenium>=4.0.0; extra == "selenium"
 Requires-Dist: webdriver-manager>=4.0.0; extra == "selenium"
+Provides-Extra: browser
+Requires-Dist: camoufox[geoip]>=0.4.11; extra == "browser"
+Requires-Dist: browserforge[all]>=1.0.0; extra == "browser"
 Provides-Extra: cli
 Requires-Dist: click>=8.0.0; extra == "cli"
 Requires-Dist: rich>=13.0.0; extra == "cli"
@@ -74,6 +77,9 @@ pytrends-modern is a **next-generation** Google Trends library that combines:
 # Basic installation
 pip install pytrends-modern
 
+# With browser mode (Camoufox for bypassing rate limits)
+pip install pytrends-modern[browser]
+
 # With Selenium support (for advanced scraping)
 pip install pytrends-modern[selenium]
 
@@ -112,6 +118,71 @@ related = pytrends.related_queries()
 print(related['Python']['top'])
 ```
 
+### 🦊 Browser Mode (Camoufox) - Bypass Rate Limits
+
+**NEW!** Use Camoufox with advanced fingerprinting to bypass Google's rate limits by using your Google account:
+
+```python
+from pytrends_modern import TrendReq, BrowserConfig
+from pytrends_modern.camoufox_setup import setup_profile
+
+# First-time setup: Configure Google account login
+setup_profile()  # Opens browser - log in to Google once
+
+# Use browser mode (persistent login, no rate limits!)
+config = BrowserConfig(headless=False)
+pytrends = TrendReq(browser_config=config)
+
+# Works like normal API
+pytrends.kw_list = ['Python']
+df = pytrends.interest_over_time()
+print(df.head())
+```
+
+**Browser Mode Limitations:**
+- ⚠️ Only 1 keyword at a time (no comparisons)
+- ⚠️ Only 'today 1-m' timeframe
+- ⚠️ Only WORLDWIDE region
+- ✅ No rate limits (uses your Google account)
+- ✅ Perfect anti-detection with Camoufox fingerprinting
+
+**Setup from command line:**
+```bash
+# Check profile status
+python -m pytrends_modern.camoufox_setup status
+
+# Run setup (opens browser for Google login)
+python -m pytrends_modern.camoufox_setup
+
+# Export profile for Docker/other machines
+python -m pytrends_modern.camoufox_setup export camoufox-profile.tar.gz
+
+# Import profile on another machine
+python -m pytrends_modern.camoufox_setup import camoufox-profile.tar.gz
+```
+
+**Docker Usage:**
+
+Yes! You can export your profile and use it in Docker containers:
+
+```bash
+# 1. Export profile locally
+python -m pytrends_modern.camoufox_setup export profile.tar.gz
+
+# 2. Use in Dockerfile
+COPY profile.tar.gz /tmp/
+RUN mkdir -p /root/.config && \
+    cd /root/.config && \
+    tar -xzf /tmp/profile.tar.gz
+
+# 3. Use headless mode in container
+config = BrowserConfig(headless=True)
+```
+
+See `Dockerfile.example` for complete Docker setup.
+
+⚠️ **Security**: Profile contains Google session - keep secure, don't commit to git!
+
 ### RSS Feed (Fast Real-Time Data)
 
 ```python

pytrends_modern-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+pytrends_modern/__init__.py,sha256=oMZFQnXNdW3SPnAvBQ-dfUghoLOD4oMpmqd6Gloxkvo,767
+pytrends_modern/browser_config.py,sha256=aEznKEaAiJ1vFPYMeNc2wiyehijnleNBFoiZIXWQcRQ,3513
+pytrends_modern/browser_config_camoufox.py,sha256=RADieQug_3-7-Pfdr_YNs929zIwaaWicyn9kAfbqh-E,2532
+pytrends_modern/camoufox_setup.py,sha256=WkytaNt64Gro8wJUPXaoUPhesDRvz460UeHGzETR6ds,10534
+pytrends_modern/cli.py,sha256=lwuXzFY5S7glSGL180dFkpnTcVsM7JfTzJ2vLKs8TLA,12784
+pytrends_modern/config.py,sha256=zPCMgdAFwcrQPMYO87dLAirkxnvpvsTx9DkWZGkl8zk,5198
+pytrends_modern/exceptions.py,sha256=3WWDiYha1Tj2Hn2TNQfAPUncdGHIJbqMLFRQjLLXm3k,1712
+pytrends_modern/proxy_extension.py,sha256=j-Cseb5G627q2G7dRdlkhqzGUG9dhmoTi1UK5wwF3u4,2214
+pytrends_modern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytrends_modern/request.py,sha256=4_cBWmcMmzPiZE6OuCBM7me65RlHKLtOPCv6kRrQtas,46606
+pytrends_modern/rss.py,sha256=6Qq8MsVJu9WtE5UcYlUze7EexT81Mq4af7pPFOMcDS0,11414
+pytrends_modern/scraper.py,sha256=x1xbFjUs7ULOBlIWLZ90G6WXJwB2EYuwUo0dWmHAjEQ,9706
+pytrends_modern/utils.py,sha256=xPf4nz4c8Mn-737PZTe6o3HChjZvIR8brIftNg0-IFE,6875
+pytrends_modern-0.2.0.dist-info/licenses/LICENSE,sha256=4K_FiN4IB1h5rffiOC8s5Tpxiv161v0eNIQJMDbvC0o,1469
+pytrends_modern-0.2.0.dist-info/METADATA,sha256=HruSpENf_WgzrxTaAR3HHMHPpC83VxF9Rzpw-7_aDp0,14302
+pytrends_modern-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrends_modern-0.2.0.dist-info/entry_points.txt,sha256=1ilOUXV2wt8NqQp2ViD-obi9k8iQANEa3eU-7S3jTgs,61
+pytrends_modern-0.2.0.dist-info/top_level.txt,sha256=bbuIEWVfkaA-sBTKf-Dzau5Ll2zlHs21o0zWtCmQG50,16
+pytrends_modern-0.2.0.dist-info/RECORD,,

pytrends_modern-0.1.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-pytrends_modern/__init__.py,sha256=rzZ0VT5yvZw-lJvoF4dl9GLTXWqv0A3TayTQmIBnxOc,615
-pytrends_modern/cli.py,sha256=lwuXzFY5S7glSGL180dFkpnTcVsM7JfTzJ2vLKs8TLA,12784
-pytrends_modern/config.py,sha256=zPCMgdAFwcrQPMYO87dLAirkxnvpvsTx9DkWZGkl8zk,5198
-pytrends_modern/exceptions.py,sha256=3WWDiYha1Tj2Hn2TNQfAPUncdGHIJbqMLFRQjLLXm3k,1712
-pytrends_modern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytrends_modern/request.py,sha256=V_7R_Ywk_QhgW--sx3s2ScQpmvuHpXfU2LCDKZJ7GcU,28211
-pytrends_modern/rss.py,sha256=6Qq8MsVJu9WtE5UcYlUze7EexT81Mq4af7pPFOMcDS0,11414
-pytrends_modern/scraper.py,sha256=x1xbFjUs7ULOBlIWLZ90G6WXJwB2EYuwUo0dWmHAjEQ,9706
-pytrends_modern/utils.py,sha256=xPf4nz4c8Mn-737PZTe6o3HChjZvIR8brIftNg0-IFE,6875
-pytrends_modern-0.1.2.dist-info/licenses/LICENSE,sha256=4K_FiN4IB1h5rffiOC8s5Tpxiv161v0eNIQJMDbvC0o,1469
-pytrends_modern-0.1.2.dist-info/METADATA,sha256=T5QU-DUrLhfmr-kzRv0oF6LJG6nIdu-JFCrbdm4MD5w,12156
-pytrends_modern-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrends_modern-0.1.2.dist-info/entry_points.txt,sha256=1ilOUXV2wt8NqQp2ViD-obi9k8iQANEa3eU-7S3jTgs,61
-pytrends_modern-0.1.2.dist-info/top_level.txt,sha256=bbuIEWVfkaA-sBTKf-Dzau5Ll2zlHs21o0zWtCmQG50,16
-pytrends_modern-0.1.2.dist-info/RECORD,,