pytrends-modern 0.2.2__tar.gz → 0.2.4__tar.gz

{pytrends_modern-0.2.2/pytrends_modern.egg-info → pytrends_modern-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrends-modern
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -139,6 +139,36 @@ df = pytrends.interest_over_time()
 print(df.head())
 ```
 
+**Avoiding 429 Rate Limits:**
+
+If you're getting 429 errors even with browser mode, use these anti-rate-limit features:
+
+```python
+import random
+from pytrends_modern import TrendReq, BrowserConfig
+
+# Add delays + rotate OS fingerprint
+os_choice = random.choice(['windows', 'macos', 'linux'])
+config = BrowserConfig(
+    headless=False,
+    min_delay=3.0,             # Min delay between requests (seconds)
+    max_delay=7.0,             # Max delay between requests
+    persistent_context=True,    # Keep Google login
+    os=os_choice,              # Rotate OS fingerprint
+    humanize=True
+)
+
+pytrends = TrendReq(browser_config=config)
+# Delays are automatically added before each request
+```
+
+**Anti-Rate-Limit Options:**
+- `min_delay` / `max_delay` - Random delay between requests (default: 2-5s)
+- `os` - Rotate between 'windows', 'macos', 'linux' for different fingerprints
+- `persistent_context=False` - Fresh profile each time (no cookies)
+- `proxy_server` - Use proxy to rotate IPs
+- `humanize=True` - Human-like cursor movements (enabled by default)
+
 **Browser Mode Limitations:**
 - ⚠️ Only 1 keyword at a time (no comparisons)
 - ⚠️ Only 'today 1-m' timeframe

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/README.md

@@ -89,6 +89,36 @@ df = pytrends.interest_over_time()
 print(df.head())
 ```
 
+**Avoiding 429 Rate Limits:**
+
+If you're getting 429 errors even with browser mode, use these anti-rate-limit features:
+
+```python
+import random
+from pytrends_modern import TrendReq, BrowserConfig
+
+# Add delays + rotate OS fingerprint
+os_choice = random.choice(['windows', 'macos', 'linux'])
+config = BrowserConfig(
+    headless=False,
+    min_delay=3.0,             # Min delay between requests (seconds)
+    max_delay=7.0,             # Max delay between requests
+    persistent_context=True,    # Keep Google login
+    os=os_choice,              # Rotate OS fingerprint
+    humanize=True
+)
+
+pytrends = TrendReq(browser_config=config)
+# Delays are automatically added before each request
+```
+
+**Anti-Rate-Limit Options:**
+- `min_delay` / `max_delay` - Random delay between requests (default: 2-5s)
+- `os` - Rotate between 'windows', 'macos', 'linux' for different fingerprints
+- `persistent_context=False` - Fresh profile each time (no cookies)
+- `proxy_server` - Use proxy to rotate IPs
+- `humanize=True` - Human-like cursor movements (enabled by default)
+
 **Browser Mode Limitations:**
 - ⚠️ Only 1 keyword at a time (no comparisons)
 - ⚠️ Only 'today 1-m' timeframe

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/examples/example_browser_mode.py

@@ -35,15 +35,15 @@ from pytrends_modern import TrendReq, BrowserConfig
 config = BrowserConfig(
     headless=False,  # Set to True for headless mode
     humanize=True,   # Human-like cursor movements
-    os='linux',      # or 'windows', 'macos'
-    geoip=True       # Auto-detect location from IP
+    os='windows',      # or 'windows', 'macos'
+    geoip=False       # Auto-detect location from IP
 )
 
 # Initialize with browser mode
 pytrends = TrendReq(browser_config=config)
 
 # Test with a keyword
-keyword = "Artificial Intelligence"
+keyword = "Brainrot"
 print(f"\n🔍 Fetching data for: {keyword}")
 print("⏳ Browser will open briefly...")
 

pytrends_modern-0.2.4/examples/test_timeframes.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Example: Using different timeframes with browser mode
+
+Test both 'today 1-m' (default) and 'today 12-m' (past 12 months)
+"""
+
+from pytrends_modern import TrendReq, BrowserConfig
+
+keyword = "Python"
+
+print("=" * 70)
+print("Testing Different Timeframes")
+print("=" * 70)
+
+# Test 1: Default timeframe (today 1-m)
+print("\n📊 Test 1: Default timeframe (past month)")
+config1 = BrowserConfig(
+    headless=False,
+    min_delay=2.0,
+    max_delay=4.0,
+)
+print(f"Timeframe: {config1.timeframe}")
+
+pytrends1 = TrendReq(browser_config=config1)
+pytrends1.kw_list = [keyword]
+df1 = pytrends1.interest_over_time()
+print(f"✓ Got {len(df1)} data points")
+print(df1.head())
+print(f"Date range: {df1.index.min()} to {df1.index.max()}")
+
+# Close first browser before opening second
+pytrends1._close_browser()
+del pytrends1
+
+# Test 2: Past 12 months
+print("\n📊 Test 2: Past 12 months")
+config2 = BrowserConfig(
+    headless=False,
+    min_delay=2.0,
+    max_delay=4.0,
+    timeframe='today 12-m'
+)
+print(f"Timeframe: {config2.timeframe}")
+
+pytrends2 = TrendReq(browser_config=config2)
+pytrends2.kw_list = [keyword]
+df2 = pytrends2.interest_over_time()
+print(f"✓ Got {len(df2)} data points")
+print(df2.head())
+print(f"Date range: {df2.index.min()} to {df2.index.max()}")
+
+print("\n✅ Both timeframes working!")
+print(f"\nPast month: {len(df1)} points")
+print(f"Past 12 months: {len(df2)} points")

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytrends-modern"
-version = "0.2.2"
+version = "0.2.4"
 description = "Modern Google Trends API - Combining the best of pytrends, with RSS feeds, Selenium scraping, DrissionPage browser automation, and enhanced features"
 readme = "README.md"
 requires-python = ">=3.8"

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pytrends_modern/__init__.py

@@ -2,7 +2,7 @@
 pytrends-modern: Modern Google Trends API
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 __author__ = "pytrends-modern contributors"
 __license__ = "MIT"
 

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pytrends_modern/browser_config_camoufox.py

@@ -1,6 +1,6 @@
 """Browser configuration for Camoufox automation"""
 
-from typing import Optional, Union
+from typing import Optional, Union, Dict, Any
 import os as os_module
 
 
@@ -12,7 +12,6 @@ class BrowserConfig:
     
     ⚠️ 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)
     
@@ -29,6 +28,15 @@ class BrowserConfig:
         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)
+        rotate_fingerprint: Generate random fingerprint for each session (default: True)
+                          Set to False to use persistent fingerprint
+        min_delay: Minimum delay between requests in seconds (default: 2)
+        max_delay: Maximum delay between requests in seconds (default: 5)
+        persistent_context: Keep browser profile between sessions (default: True)
+                          Set to False to use fresh profile each time (helps avoid 429)
+        timeframe: Time range for trends data (default: 'today 1-m')
+                  - 'today 1-m': Past month
+                  - 'today 12-m': Past 12 months
     
     Example:
         >>> from pytrends_modern import TrendReq, BrowserConfig
@@ -57,6 +65,12 @@ class BrowserConfig:
         humanize: bool = True,
         os: str = 'linux',
         geoip: bool = True,
+        rotate_fingerprint: bool = True,
+        min_delay: float = 2.0,
+        max_delay: float = 5.0,
+        persistent_context: bool = True,
+        custom_config: Optional[Dict[str, Any]] = None,
+        timeframe: str = 'today 1-m',
     ):
         self.headless = headless
         self.proxy_server = proxy_server
@@ -66,4 +80,10 @@ class BrowserConfig:
         self.humanize = humanize
         self.os = os
         self.geoip = geoip if proxy_server else False
+        self.rotate_fingerprint = rotate_fingerprint
+        self.min_delay = min_delay
+        self.max_delay = max_delay
+        self.persistent_context = persistent_context
+        self.custom_config = custom_config or {}
+        self.timeframe = timeframe
 

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pytrends_modern/request.py

@@ -92,7 +92,6 @@ class TrendReq:
                            
                            ⚠️ 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
         """
@@ -109,7 +108,7 @@ class TrendReq:
             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"
+                "   - Timeframe: 'today 1-m' (default) or 'today 12-m'\n"
                 "   - Only WORLDWIDE geo supported\n"
                 "   - Requires Google account login (first run)\n"
                 "   - Login session is saved for future runs",
@@ -170,6 +169,44 @@ class TrendReq:
         """Get a random user agent"""
         return random.choice(USER_AGENTS) if self.rotate_user_agent else USER_AGENTS[0]
     
+    def _browserforge_to_camoufox(self, fingerprint) -> Dict:
+        """Convert BrowserForge fingerprint to Camoufox config"""
+        config = {}
+        
+        # Navigator properties
+        if hasattr(fingerprint, 'navigator'):
+            nav = fingerprint.navigator
+            if hasattr(nav, 'userAgent'):
+                config['navigator.userAgent'] = nav.userAgent
+            if hasattr(nav, 'language'):
+                config['navigator.language'] = nav.language
+            if hasattr(nav, 'hardwareConcurrency'):
+                config['navigator.hardwareConcurrency'] = nav.hardwareConcurrency
+            if hasattr(nav, 'maxTouchPoints'):
+                config['navigator.maxTouchPoints'] = nav.maxTouchPoints
+        
+        # Screen properties
+        if hasattr(fingerprint, 'screen'):
+            scr = fingerprint.screen
+            if hasattr(scr, 'width'):
+                config['screen.width'] = scr.width
+            if hasattr(scr, 'height'):
+                config['screen.height'] = scr.height
+            if hasattr(scr, 'availWidth'):
+                config['screen.availWidth'] = scr.availWidth
+            if hasattr(scr, 'availHeight'):
+                config['screen.availHeight'] = scr.availHeight
+        
+        return config
+    
+    def _add_request_delay(self) -> None:
+        """Add random delay between requests to avoid rate limiting"""
+        if hasattr(self.browser_config, 'min_delay') and hasattr(self.browser_config, 'max_delay'):
+            import time
+            import random
+            delay = random.uniform(self.browser_config.min_delay, self.browser_config.max_delay)
+            time.sleep(delay)
+    
     def _init_camoufox(self) -> None:
         """Initialize Camoufox browser with persistent context"""
         try:
@@ -212,15 +249,19 @@ class TrendReq:
         
         # Initialize Camoufox with persistent context
         try:
+            # Note: Camoufox automatically generates BrowserForge fingerprints
+            # based on the 'os' parameter. No need to manually pass fingerprints.
+            
             # 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,
+                persistent_context=self.browser_config.persistent_context,
+                user_data_dir=user_data_dir if self.browser_config.persistent_context else None,
                 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
+                proxy=proxy_config,
+                config=self.browser_config.custom_config if self.browser_config.custom_config else None
             )
             
             # Enter the context manager to get the browser context
@@ -303,13 +344,27 @@ class TrendReq:
         if not self.browser_page:
             raise exceptions.BrowserError("Browser not initialized")
         
+        # Add random delay before request (anti-rate-limiting)
+        self._add_request_delay()
+        
         # 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"
+        
+        # Get timeframe from config (default: 'today 1-m')
+        timeframe = getattr(self.browser_config, 'timeframe', 'today 1-m')
+        
+        # Build URL with or without date parameter
+        if timeframe == 'today 12-m':
+            # Past 12 months - no date parameter needed
+            url = f"https://trends.google.com/trends/explore?q={encoded_keyword}&hl=en-GB"
+        else:
+            # Default: today 1-m or custom timeframe
+            encoded_timeframe = urllib.parse.quote(timeframe)
+            url = f"https://trends.google.com/trends/explore?date={encoded_timeframe}&q={encoded_keyword}&hl=en-GB"
         
         try:
             # Navigate and wait for network idle

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pytrends_modern/request_async.py

@@ -56,6 +56,20 @@ class AsyncTrendReq:
         """Async context manager exit"""
         await self._close_browser()
         
+    def _browserforge_to_camoufox(self, fingerprint) -> Dict:
+        """Convert BrowserForge fingerprint to Camoufox config"""
+        # Reuse the sync version's implementation
+        from pytrends_modern.request import TrendReq
+        return TrendReq._browserforge_to_camoufox(self, fingerprint)
+    
+    async def _add_request_delay(self) -> None:
+        """Add random delay between requests to avoid rate limiting (async)"""
+        if hasattr(self.browser_config, 'min_delay') and hasattr(self.browser_config, 'max_delay'):
+            import asyncio
+            import random
+            delay = random.uniform(self.browser_config.min_delay, self.browser_config.max_delay)
+            await asyncio.sleep(delay)
+    
     async def _init_camoufox(self) -> None:
         """Initialize Camoufox browser with persistent context (async)"""
         try:
@@ -98,15 +112,19 @@ class AsyncTrendReq:
         
         # Initialize AsyncCamoufox with persistent context
         try:
+            # Note: Camoufox automatically generates BrowserForge fingerprints
+            # based on the 'os' parameter. No need to manually pass fingerprints.
+            
             # AsyncCamoufox() returns a context manager
             camoufox_manager = AsyncCamoufox(
-                persistent_context=True,
-                user_data_dir=user_data_dir,
+                persistent_context=self.browser_config.persistent_context,
+                user_data_dir=user_data_dir if self.browser_config.persistent_context else None,
                 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
+                proxy=proxy_config,
+                config=self.browser_config.custom_config if self.browser_config.custom_config else None
             )
             
             # Enter the context manager to get the browser context
@@ -189,13 +207,27 @@ class AsyncTrendReq:
         if not self.browser_page:
             raise exceptions.BrowserError("Browser not initialized")
         
+        # Add random delay before request (anti-rate-limiting)
+        await self._add_request_delay()
+        
         # 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"
+        
+        # Get timeframe from config (default: 'today 1-m')
+        timeframe = getattr(self.browser_config, 'timeframe', 'today 1-m')
+        
+        # Build URL with or without date parameter
+        if timeframe == 'today 12-m':
+            # Past 12 months - no date parameter needed
+            url = f"https://trends.google.com/trends/explore?q={encoded_keyword}&hl=en-GB"
+        else:
+            # Default: today 1-m or custom timeframe
+            encoded_timeframe = urllib.parse.quote(timeframe)
+            url = f"https://trends.google.com/trends/explore?date={encoded_timeframe}&q={encoded_keyword}&hl=en-GB"
         
         try:
             # Navigate and wait for network idle

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4/pytrends_modern.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrends-modern
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -139,6 +139,36 @@ df = pytrends.interest_over_time()
 print(df.head())
 ```
 
+**Avoiding 429 Rate Limits:**
+
+If you're getting 429 errors even with browser mode, use these anti-rate-limit features:
+
+```python
+import random
+from pytrends_modern import TrendReq, BrowserConfig
+
+# Add delays + rotate OS fingerprint
+os_choice = random.choice(['windows', 'macos', 'linux'])
+config = BrowserConfig(
+    headless=False,
+    min_delay=3.0,             # Min delay between requests (seconds)
+    max_delay=7.0,             # Max delay between requests
+    persistent_context=True,    # Keep Google login
+    os=os_choice,              # Rotate OS fingerprint
+    humanize=True
+)
+
+pytrends = TrendReq(browser_config=config)
+# Delays are automatically added before each request
+```
+
+**Anti-Rate-Limit Options:**
+- `min_delay` / `max_delay` - Random delay between requests (default: 2-5s)
+- `os` - Rotate between 'windows', 'macos', 'linux' for different fingerprints
+- `persistent_context=False` - Fresh profile each time (no cookies)
+- `proxy_server` - Use proxy to rotate IPs
+- `humanize=True` - Human-like cursor movements (enabled by default)
+
 **Browser Mode Limitations:**
 - ⚠️ Only 1 keyword at a time (no comparisons)
 - ⚠️ Only 'today 1-m' timeframe

{pytrends_modern-0.2.2 → pytrends_modern-0.2.4}/pytrends_modern.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ examples/basic_usage.py
 examples/example_browser_mode.py
 examples/example_docker_usage.py
 examples/test_async_integration.py
+examples/test_timeframes.py
 pytrends_modern/__init__.py
 pytrends_modern/browser_config.py
 pytrends_modern/browser_config_camoufox.py