Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException, status  
+from fastapi import FastAPI, HTTPException, status, BackgroundTasks  
 from fastapi.responses import StreamingResponse  
 import instaloader  
 import requests  
@@ -7,6 +7,8 @@ import time
 import logging  
 import random  
 from functools import wraps  
+import json  
+from datetime import datetime, timedelta  
 
 # Configure logging  
 logging.basicConfig(  
@@ -28,19 +30,32 @@ SESSION_FILE = os.path.join(SESSION_DIR, f"session-{INSTAGRAM_USERNAME}") if INS
 # Create session directory if not exists  
 os.makedirs(SESSION_DIR, exist_ok=True)  
 
+# Rate limiting state  
+LAST_REQUEST_TIME = {}  
+COOLDOWN_PERIODS = {}  
+
 USER_AGENTS = [  
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",  
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15",  
-    "Mozilla/5.0 (Linux; Android 10; SM-G981B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"  
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",  
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1",  
+    "Mozilla/5.0 (iPad; CPU OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1"  
 ]  
 
-def get_instaloader() -> instaloader.Instaloader:  
+def get_instaloader(force_login=False) -> instaloader.Instaloader:  
     """Create and configure Instaloader instance with proper parameters"""  
     L = instaloader.Instaloader(  
         sleep=True,  
-        request_timeout=300,  
-        max_connection_attempts=2,  
+        request_timeout=30,  # Reduced timeout  
+        max_connection_attempts=3,  
         user_agent=random.choice(USER_AGENTS),  
+        download_pictures=False,  
+        download_videos=False,  
+        download_video_thumbnails=False,  
+        download_geotags=False,  
+        download_comments=False,  
+        compress_json=False,  
+        post_metadata_txt_pattern=''  
     )  
     
     if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:  
@@ -51,33 +66,50 @@ def get_instaloader() -> instaloader.Instaloader:
         )  
 
     try:  
-        if SESSION_FILE and os.path.exists(SESSION_FILE):  
+        if not force_login and SESSION_FILE and os.path.exists(SESSION_FILE):  
             logger.info(f"Attempting to load session from {SESSION_FILE}")  
             try:  
                 L.load_session_from_file(INSTAGRAM_USERNAME, SESSION_FILE)  
                 logger.info("Session loaded successfully")  
-                # Verify session is still valid  
-                test_profile = instaloader.Profile.from_username(L.context, INSTAGRAM_USERNAME)  
-                if not test_profile.is_verified:  
-                    raise Exception("Session validation failed")  
-                return L  
+                # Test session without using is_verified  
+                try:  
+                    test_profile = instaloader.Profile.from_username(L.context, INSTAGRAM_USERNAME)  
+                    logger.info(f"Session test: Profile ID {test_profile.userid} verified")  
+                    return L  
+                except Exception as e:  
+                    logger.warning(f"Session test failed: {str(e)}")  
+                    raise Exception("Invalid session")  
             except Exception as e:  
                 logger.warning(f"Session load failed: {str(e)}, performing fresh login")  
-
+                
+        # Add delay before login to mimic human behavior  
+        time.sleep(random.uniform(1.0, 3.0))  
+                
         logger.info("Starting fresh login process")  
         L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)  
         
+        # Set realistic headers  
         L.context._session.headers.update({  
             'Accept-Language': 'en-US,en;q=0.9',  
             'Accept-Encoding': 'gzip, deflate, br',  
             'Referer': 'https://www.instagram.com/',  
+            'Origin': 'https://www.instagram.com',  
             'DNT': '1',  
+            'Connection': 'keep-alive',  
+            'Sec-Fetch-Dest': 'empty',  
+            'Sec-Fetch-Mode': 'cors',  
+            'Sec-Fetch-Site': 'same-origin',  
+            'Pragma': 'no-cache',  
+            'Cache-Control': 'no-cache',  
         })  
         
         if SESSION_FILE:  
             L.save_session_to_file(SESSION_FILE)  
             logger.info(f"Saved new session to {SESSION_FILE}")  
         
+        # Add delay after login  
+        time.sleep(random.uniform(2.0, 4.0))  
+        
         return L  
 
     except instaloader.exceptions.BadCredentialsException as e:  
@@ -99,23 +131,93 @@ def get_instaloader() -> instaloader.Instaloader:
             detail="Instagram login service unavailable"  
         )  
 
+def is_rate_limited(username: str) -> bool:  
+    """Check if a given username is currently rate limited"""  
+    # If in cooldown period, check if it's expired  
+    if username in COOLDOWN_PERIODS:  
+        if datetime.now() < COOLDOWN_PERIODS[username]:  
+            remaining = (COOLDOWN_PERIODS[username] - datetime.now()).seconds  
+            logger.warning(f"User {username} in cooldown for {remaining} more seconds")  
+            return True  
+        else:  
+            # Cooldown expired  
+            del COOLDOWN_PERIODS[username]  
+    
+    # Check time since last request  
+    if username in LAST_REQUEST_TIME:  
+        elapsed = (datetime.now() - LAST_REQUEST_TIME[username]).seconds  
+        min_interval = 60  # Minimum 60 seconds between requests  
+        if elapsed < min_interval:  
+            logger.warning(f"Rate limiting {username}: {elapsed}s elapsed, need {min_interval}s")  
+            return True  
+    
+    # Update last request time  
+    LAST_REQUEST_TIME[username] = datetime.now()  
+    return False  
+
+def handle_rate_limit_error(username: str):  
+    """Handle rate limit by setting cooldown period"""  
+    # Set cooldown period (increases with repeated issues)  
+    cooldown_minutes = 5  
+    if username in COOLDOWN_PERIODS:  
+        cooldown_minutes = min(cooldown_minutes * 2, 30)  # Exponential backoff up to 30 minutes  
+    
+    COOLDOWN_PERIODS[username] = datetime.now() + timedelta(minutes=cooldown_minutes)  
+    logger.warning(f"Setting cooldown for {username} for {cooldown_minutes} minutes")  
+
 def handle_instagram_errors(func):  
     @wraps(func)  
     async def wrapper(*args, **kwargs):  
+        # Extract username from request path  
+        request_username = ""  
+        if len(args) > 1 and hasattr(args[1], '__str__'):  
+            request_username = str(args[1])  
+            
         try:  
+            # Check for rate limiting  
+            if request_username and is_rate_limited(request_username):  
+                raise HTTPException(  
+                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                    detail="Rate limit exceeded. Please try again later."  
+                )  
+                
             return await func(*args, **kwargs)  
+            
+        except instaloader.exceptions.ConnectionException as e:  
+            error_message = str(e)  
+            logger.error("Connection error: %s", error_message)  
+            
+            if "401 Unauthorized" in error_message and "Please wait a few minutes" in error_message:  
+                if request_username:  
+                    handle_rate_limit_error(request_username)  
+                raise HTTPException(  
+                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                    detail="Instagram rate limit exceeded. Please try again later."  
+                )  
+            elif "404 Not Found" in error_message:  
+                raise HTTPException(  
+                    status_code=status.HTTP_404_NOT_FOUND,   
+                    detail="Profile not found or no stories available"  
+                )  
+            else:  
+                raise HTTPException(  
+                    status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
+                    detail="Instagram service unavailable"  
+                )  
+                
         except instaloader.exceptions.QueryReturnedBadRequestException as e:  
             logger.error("API error 400: %s", str(e))  
+            if request_username:  
+                handle_rate_limit_error(request_username)  
             raise HTTPException(  
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
                 detail="Instagram rate limit exceeded"  
             )  
-        except instaloader.exceptions.ConnectionException as e:  
-            logger.error("Connection error: %s", str(e))  
-            raise HTTPException(  
-                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
-                detail="Instagram service unavailable"  
-            )  
+            
+        except HTTPException:  
+            # Re-raise HTTP exceptions without modification  
+            raise  
+            
         except Exception as e:  
             logger.error("Unexpected error: %s", str(e))  
             raise HTTPException(  
@@ -126,45 +228,57 @@ def handle_instagram_errors(func):
 
 @app.get("/stories/{username}")  
 @handle_instagram_errors  
-async def get_stories(username: str):  
+async def get_stories(username: str, background_tasks: BackgroundTasks):  
     """Retrieve stories with enhanced anti-detection measures"""  
     logger.info(f"Processing request for @{username}")  
     
     try:  
+        # Get loader with session  
         L = get_instaloader()  
         logger.info("Instaloader instance configured")  
         
-        # Randomized delay before profile request  
-        delay = random.uniform(2.5, 5.5)  
+        # Randomized delay before profile request (more natural)  
+        delay = random.uniform(1.5, 3.0)  
         logger.debug(f"Applying initial delay of {delay:.2f}s")  
         time.sleep(delay)  
         
         # Profile lookup with retry  
+        profile = None  
         for attempt in range(3):  
             try:  
                 logger.info(f"Fetching profile (attempt {attempt+1}/3)")  
                 profile = instaloader.Profile.from_username(L.context, username)  
                 break  
             except instaloader.exceptions.QueryReturnedBadRequestException:  
-                wait_time = (attempt + 1) * 10  
-                logger.warning(f"Rate limited, waiting {wait_time}s")  
+                wait_time = (attempt + 1) * random.uniform(3.0, 5.0)  
+                logger.warning(f"Rate limited, waiting {wait_time:.2f}s")  
                 time.sleep(wait_time)  
-        else:  
+            except instaloader.exceptions.ConnectionException as e:  
+                if "401 Unauthorized" in str(e) and "Please wait a few minutes" in str(e):  
+                    # Try with a fresh login if session might be expired  
+                    if attempt < 2:  # Only try this once  
+                        logger.warning("Session may be expired, trying with fresh login")  
+                        L = get_instaloader(force_login=True)  
+                        time.sleep(random.uniform(4.0, 6.0))  
+                        continue  
+                raise  
+        
+        if profile is None:  
             raise HTTPException(  
                 status.HTTP_429_TOO_MANY_REQUESTS,  
                 "Too many attempts to access Instagram"  
             )  
 
         logger.info(f"Access check for @{username}")  
-        if not profile.has_public_story and not profile.is_followed_by_viewer:  
-            logger.warning("Private profile access denied")  
+        if not profile.has_viewable_story:  
+            logger.warning("No viewable story")  
             raise HTTPException(  
-                status.HTTP_403_FORBIDDEN,  
+                status.HTTP_404_NOT_FOUND,  
                 "No accessible stories for this profile"  
             )  
 
-        # Additional delay before story fetch  
-        time.sleep(random.uniform(1.5, 3.5))  
+        # Additional delay before story fetch (variable to look more natural)  
+        time.sleep(random.uniform(1.0, 2.5))  
         
         logger.info("Fetching stories")  
         stories = []  
@@ -179,14 +293,16 @@ async def get_stories(username: str):
                         "timestamp": item.date_utc.isoformat(),  
                     }  
                     
-                    # Only try to add view_count if it's a video and the attribute exists  
+                    # Add any available metadata safely  
+                    if hasattr(item, 'owner_username'):  
+                        story_data["username"] = item.owner_username  
+                        
+                    # Only try to add view_count if it's a video  
                     if item.is_video:  
                         try:  
-                            # Safely check if view_count attribute exists  
                             if hasattr(item, 'view_count'):  
                                 story_data["views"] = item.view_count  
                         except AttributeError:  
-                            # Skip adding views if the attribute doesn't exist  
                             pass  
                     
                     stories.append(story_data)  
@@ -205,11 +321,14 @@ async def get_stories(username: str):
                 "No active stories available"  
             )  
 
-        # Final randomized delay  
-        time.sleep(random.uniform(0.5, 1.5))  
+        # Queue session save in background to not delay response  
+        background_tasks.add_task(lambda: L.save_session_to_file(SESSION_FILE) if SESSION_FILE else None)  
+        
+        # Final randomized delay before response (looks more natural)  
+        time.sleep(random.uniform(0.3, 0.7))  
         
         logger.info(f"Returning {len(stories)} stories")  
-        return {"data": stories}  
+        return {"data": stories, "count": len(stories), "username": username}  
 
     except Exception as e:  
         logger.error(f"Critical failure: {str(e)}")  
@@ -230,21 +349,26 @@ async def download_media(url: str):
             )  
             
         # Random delay to avoid detection patterns  
-        time.sleep(random.uniform(1.0, 3.0))  
+        time.sleep(random.uniform(0.5, 1.5))  
         
         # Configure headers to mimic a browser  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
             "Accept": "*/*",  
             "Accept-Language": "en-US,en;q=0.9",  
+            "Accept-Encoding": "gzip, deflate, br",  
             "Referer": "https://www.instagram.com/",  
+            "Origin": "https://www.instagram.com",  
             "Sec-Fetch-Dest": "empty",  
             "Sec-Fetch-Mode": "cors",  
             "Sec-Fetch-Site": "cross-site",  
+            "Pragma": "no-cache",  
+            "Cache-Control": "no-cache",  
         }  
         
         # Request the media with a session  
-        response = requests.get(url, headers=headers, stream=True, timeout=30)  
+        session = requests.Session()  
+        response = session.get(url, headers=headers, stream=True, timeout=10)  
         response.raise_for_status()  
         
         # Determine content type from response or URL  
@@ -276,4 +400,9 @@ async def download_media(url: str):
         raise HTTPException(  
             status_code=status.HTTP_502_BAD_GATEWAY,  
             detail="Failed to download media"  
-        )
+        )  
+
+# Add a health check endpoint  
+@app.get("/health")  
+async def health_check():  
+    return {"status": "ok", "timestamp": datetime.now().isoformat()}