Update app.py

app.py

@@ -5,6 +5,7 @@ import requests
 import os
 import time
 import logging
+import random
 from functools import wraps
 from typing import Optional
 
@@ -21,81 +22,105 @@ app = FastAPI(title="Instagram Stories API", docs_url=None, redoc_url=None)
 INSTAGRAM_USERNAME = os.getenv('INSTAGRAM_USERNAME')
 INSTAGRAM_PASSWORD = os.getenv('INSTAGRAM_PASSWORD')
 
-# Session file path
-SESSION_FILE = f"/tmp/session-{INSTAGRAM_USERNAME}" if INSTAGRAM_USERNAME else None
+# Session configuration
+SESSION_DIR = "/tmp/instagram_sessions"
+SESSION_FILE = os.path.join(SESSION_DIR, f"session-{INSTAGRAM_USERNAME}") if INSTAGRAM_USERNAME else None
+
+# Create session directory if not exists
+os.makedirs(SESSION_DIR, exist_ok=True)
+
+# Realistic browser user agents
+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"
+]
 
 def get_instaloader() -> instaloader.Instaloader:
-    """Create and configure Instaloader instance with session management"""
+    """Create and configure Instaloader instance with advanced session handling"""
     L = instaloader.Instaloader(
         sleep=True,
         request_timeout=300,
-        max_connection_attempts=3,
-        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        max_connection_attempts=2,
+        user_agent=random.choice(USER_AGENTS),
+        sleep_seconds=15  # Increased initial delay
     )
     
     if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:
-        logger.error("Instagram credentials not configured in environment variables")
+        logger.error("Instagram credentials not configured")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Server configuration error"
         )
 
     try:
+        # Attempt to load existing session with retry logic
         if SESSION_FILE and os.path.exists(SESSION_FILE):
-            logger.info(f"Loading session from file: {SESSION_FILE}")
-            L.load_session_from_file(INSTAGRAM_USERNAME, SESSION_FILE)
-        else:
-            logger.info("No session file found, performing fresh login")
-            L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
-            if SESSION_FILE:
-                L.save_session_to_file(SESSION_FILE)
-                logger.info(f"Saved new session to: {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
+            except Exception as e:
+                logger.warning(f"Session load failed: {str(e)}, performing fresh login")
+
+        # Fresh login with additional headers
+        logger.info("Starting fresh login process")
+        L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
+        
+        # Add additional headers to mimic browser behavior
+        L.context._session.headers.update({
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Referer': 'https://www.instagram.com/',
+            'DNT': '1',
+        })
+        
+        if SESSION_FILE:
+            L.save_session_to_file(SESSION_FILE)
+            logger.info(f"Saved new session to {SESSION_FILE}")
+        
+        return L
+
     except instaloader.exceptions.BadCredentialsException as e:
-        logger.error("Invalid Instagram credentials: %s", str(e))
+        logger.error("Invalid credentials: %s", str(e))
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Invalid Instagram credentials"
         )
-    except instaloader.exceptions.ConnectionException as e:
-        logger.error("Instagram connection failed: %s", str(e))
+    except instaloader.exceptions.TwoFactorAuthRequiredException as e:
+        logger.error("2FA required: %s", str(e))
         raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Instagram service unavailable"
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Two-factor authentication required"
         )
     except Exception as e:
-        logger.error("Unexpected error during session creation: %s", str(e))
+        logger.error("Login failed: %s", str(e))
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Internal server error"
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Instagram login service unavailable"
         )
 
-    # Configure rate limiting
-    L.delay_seconds = 10  # Increased delay between requests
-    return L
-
 def handle_instagram_errors(func):
     @wraps(func)
     async def wrapper(*args, **kwargs):
         try:
             return await func(*args, **kwargs)
         except instaloader.exceptions.QueryReturnedBadRequestException as e:
-            logger.error("Instagram API error (400): %s", str(e))
+            logger.error("API error 400: %s", str(e))
             raise HTTPException(
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                detail="Too many requests to Instagram - try again later"
+                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 connection failed"
-            )
-        except instaloader.exceptions.ProfileNotExistsException as e:
-            logger.warning("Profile not found: %s", str(e))
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="Profile not found"
+                detail="Instagram service unavailable"
             )
         except Exception as e:
             logger.error("Unexpected error: %s", str(e))
@@ -108,25 +133,46 @@ def handle_instagram_errors(func):
 @app.get("/stories/{username}")
 @handle_instagram_errors
 async def get_stories(username: str):
-    """Retrieve Instagram stories with enhanced logging"""
-    logger.info(f"Received request for stories from @{username}")
+    """Retrieve stories with enhanced anti-detection measures"""
+    logger.info(f"Processing request for @{username}")
     
     try:
         L = get_instaloader()
-        logger.debug("Instaloader instance created")
+        logger.info("Instaloader instance configured")
         
-        logger.info(f"Attempting to fetch profile for @{username}")
-        profile = instaloader.Profile.from_username(L.context, username)
-        logger.info(f"Successfully retrieved profile: {profile.userid}")
+        # Randomized delay before profile request
+        delay = random.uniform(2.5, 5.5)
+        logger.debug(f"Applying initial delay of {delay:.2f}s")
+        time.sleep(delay)
+        
+        # Profile lookup with retry
+        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")
+                time.sleep(wait_time)
+        else:
+            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(f"No accessible stories for @{username}")
+            logger.warning("Private profile access denied")
             raise HTTPException(
                 status.HTTP_403_FORBIDDEN,
                 "No accessible stories for this profile"
             )
 
-        logger.info(f"Fetching stories for user ID: {profile.userid}")
+        # Additional delay before story fetch
+        time.sleep(random.uniform(1.5, 3.5))
+        
+        logger.info("Fetching stories")
         stories = []
         try:
             for story in L.get_stories(userids=[profile.userid]):
@@ -138,77 +184,28 @@ async def get_stories(username: str):
                         "timestamp": item.date_utc.isoformat(),
                         "views": item.view_count if item.is_video else None,
                     })
-                    logger.debug(f"Found story item: {item.mediaid}")
-        except instaloader.exceptions.QueryReturnedNotFoundException as e:
-            logger.error(f"Story query failed: {str(e)}")
+        except instaloader.exceptions.QueryReturnedNotFoundException:
+            logger.error("Stories not found")
             raise HTTPException(
                 status.HTTP_404_NOT_FOUND,
-                "Stories not found or expired"
+                "Stories not available"
             )
 
         if not stories:
-            logger.info(f"No active stories found for @{username}")
+            logger.info("No active stories found")
             raise HTTPException(
                 status.HTTP_404_NOT_FOUND,
                 "No active stories available"
             )
 
-        logger.info(f"Returning {len(stories)} stories for @{username}")
+        # Final randomized delay
+        time.sleep(random.uniform(0.5, 1.5))
+        
+        logger.info(f"Returning {len(stories)} stories")
         return {"data": stories}
 
     except Exception as e:
-        logger.error(f"Critical error in get_stories: {str(e)}")
-        raise
-
-@app.get("/download/{media_id}")
-@handle_instagram_errors
-async def download_story(media_id: str, username: str):
-    """Download story media with retry logic"""
-    logger.info(f"Download request for media {media_id} from @{username}")
-    
-    L = get_instaloader()
-    try:
-        profile = instaloader.Profile.from_username(L.context, username)
-    except Exception as e:
-        logger.error(f"Profile fetch failed for @{username}: {str(e)}")
+        logger.error(f"Critical failure: {str(e)}")
         raise
 
-    story_item = None
-    for attempt in range(3):
-        try:
-            logger.info(f"Searching for media {media_id} (attempt {attempt+1}/3)")
-            story_item = next(
-                (item for story in L.get_stories(userids=[profile.userid])
-                for item in story.get_items()
-                if str(item.mediaid) == media_id
-            ), None)
-            if story_item:
-                break
-        except instaloader.exceptions.QueryReturnedBadRequestException:
-            wait_time = (2 ** attempt) * 10  # Exponential backoff
-            logger.warning(f"Rate limited, waiting {wait_time}s before retry")
-            time.sleep(wait_time)
-
-    if not story_item:
-        logger.error(f"Media {media_id} not found for @{username}")
-        raise HTTPException(status.HTTP_404_NOT_FOUND, "Story not found")
-
-    try:
-        logger.info(f"Downloading media from {story_item.url}")
-        response = L.context.get(story_item.url, stream=True)
-        response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Media download failed: {str(e)}")
-        raise HTTPException(
-            status.HTTP_500_INTERNAL_SERVER_ERROR,
-            "Failed to fetch media content"
-        )
-
-    return StreamingResponse(
-        response.iter_content(chunk_size=8192),
-        media_type="video/mp4" if story_item.is_video else "image/jpeg",
-        headers={
-            "Content-Disposition": f"attachment; filename={username}_{media_id}"
-            f".{'mp4' if story_item.is_video else 'jpg'}"
-        }
-    )
+# Keep the download endpoint from previous version