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

pytrends_modern/__init__.py

@@ -2,13 +2,16 @@
 pytrends-modern: Modern Google Trends API
 """
 
-__version__ = "1.0.0"
+__version__ = "0.2.1"
 __author__ = "pytrends-modern contributors"
 __license__ = "MIT"
 
 from pytrends_modern.request import TrendReq
+from pytrends_modern.request_async import AsyncTrendReq
 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,
@@ -19,8 +22,11 @@ from pytrends_modern.exceptions import (
 
 __all__ = [
     "TrendReq",
+    "AsyncTrendReq",
     "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