Update app.py

app.py

@@ -1,14 +1,15 @@
 from fastapi import FastAPI, HTTPException, status, BackgroundTasks  
-from fastapi.responses import StreamingResponse  
-import instaloader  
+from fastapi.responses import StreamingResponse, JSONResponse  
 import requests  
 import os  
 import time  
 import logging  
 import random  
-from functools import wraps  
-from datetime import datetime, timedelta  
 import json  
+from datetime import datetime, timedelta  
+import hashlib  
+import re  
+from urllib.parse import quote  
 
 # Configure logging  
 logging.basicConfig(  
@@ -23,29 +24,30 @@ 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 configuration  
-SESSION_DIR = "/tmp/instagram_sessions"  
-SESSION_FILE = os.path.join(SESSION_DIR, f"session-{INSTAGRAM_USERNAME}") if INSTAGRAM_USERNAME else None  
+# Configuration  
 CACHE_DIR = "/tmp/instagram_cache"  
-
-# Create required directories  
-os.makedirs(SESSION_DIR, exist_ok=True)  
+COOKIE_FILE = "/tmp/instagram_cookies.json"  
 os.makedirs(CACHE_DIR, exist_ok=True)  
 
-# Simple memory cache  
+# Cache state  
 STORY_CACHE = {}  
 CACHE_EXPIRY = {}  
-LAST_REQUEST = {}  
-COOLDOWN_UNTIL = {}  
+RATE_LIMITS = {}  
+
+# Session state  
+SESSION = None  
+SESSION_LAST_REFRESH = None  
 
+# 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 (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 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",  
+    "Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",  
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/116.0.5845.0 Mobile/15E148 Safari/604.1",  
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1"  
 ]  
 
 def get_cache_key(username):  
-    """Simple cache key generator"""  
+    """Generate a cache key from username"""  
     return username.lower()  
 
 def get_cached_stories(username):  
@@ -81,222 +83,250 @@ def save_to_cache(username, data, minutes=30):
 
 def is_rate_limited(username):  
     """Check if we should rate limit this request"""  
-    # Check if in cooldown  
-    if username in COOLDOWN_UNTIL:  
-        if datetime.now() < COOLDOWN_UNTIL[username]:  
-            seconds_left = (COOLDOWN_UNTIL[username] - datetime.now()).total_seconds()  
-            logger.warning(f"{username} in cooldown for {int(seconds_left)}s")  
+    # Check rate limits  
+    key = username.lower()  
+    if key in RATE_LIMITS:  
+        if datetime.now() < RATE_LIMITS[key]["until"]:  
+            seconds = (RATE_LIMITS[key]["until"] - datetime.now()).total_seconds()  
+            logger.warning(f"Rate limited {username} for {int(seconds)}s")  
             return True  
         else:  
-            # Cooldown expired  
-            COOLDOWN_UNTIL.pop(username)  
-    
-    # Check request frequency  
-    if username in LAST_REQUEST:  
-        seconds_since = (datetime.now() - LAST_REQUEST[username]).total_seconds()  
-        if seconds_since < 60:  # 1 minute minimum between requests  
-            logger.warning(f"Rate limiting {username}: only {int(seconds_since)}s since last request")  
-            return True  
-    
-    # Update last request time  
-    LAST_REQUEST[username] = datetime.now()  
+            # Expired rate limit  
+            RATE_LIMITS.pop(key)  
     return False  
 
-def set_cooldown(username, minutes=30):  
-    """Set a cooldown period for a username"""  
-    COOLDOWN_UNTIL[username] = datetime.now() + timedelta(minutes=minutes)  
-    logger.warning(f"Setting {minutes}m cooldown for {username}")  
+def set_rate_limit(username, minutes=15):  
+    """Set rate limiting for a username"""  
+    key = username.lower()  
+    RATE_LIMITS[key] = {  
+        "until": datetime.now() + timedelta(minutes=minutes),  
+        "requests": 0  
+    }  
+    logger.warning(f"Setting rate limit for {username} for {minutes} minutes")  
 
-def get_instaloader():  
-    """Create and configure Instaloader instance"""  
-    L = instaloader.Instaloader(  
-        sleep=True,  
-        request_timeout=30,  
-        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=''  
-    )  
+def get_instagram_session():  
+    """Get or create an Instagram session"""  
+    global SESSION, SESSION_LAST_REFRESH  
     
-    if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:  
-        logger.error("Instagram credentials not configured")  
-        raise HTTPException(  
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
-            detail="Server configuration error"  
-        )  
-
-    try:  
-        if SESSION_FILE and os.path.exists(SESSION_FILE):  
-            logger.info(f"Loading session from {SESSION_FILE}")  
+    # Create new session if none exists or it's older than 30 minutes  
+    if (SESSION is None or   
+        SESSION_LAST_REFRESH is None or   
+        (datetime.now() - SESSION_LAST_REFRESH).total_seconds() > 1800):  
+        
+        SESSION = requests.Session()  
+        SESSION.headers.update({  
+            'User-Agent': random.choice(USER_AGENTS),  
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',  
+            'Accept-Language': 'en-US,en;q=0.5',  
+            'Accept-Encoding': 'gzip, deflate, br',  
+            'Connection': 'keep-alive',  
+            'Upgrade-Insecure-Requests': '1',  
+            'Sec-Fetch-Dest': 'document',  
+            'Sec-Fetch-Mode': 'navigate',  
+            'Sec-Fetch-Site': 'none',  
+            'Sec-Fetch-User': '?1',  
+            'TE': 'trailers',  
+        })  
+        
+        # Load cookies if available  
+        if os.path.exists(COOKIE_FILE):  
             try:  
-                L.load_session_from_file(INSTAGRAM_USERNAME, SESSION_FILE)  
-                logger.info("Session loaded successfully")  
-                return L  
+                with open(COOKIE_FILE, 'r') as f:  
+                    cookies = json.load(f)  
+                    
+                for cookie in cookies:  
+                    SESSION.cookies.set(cookie['name'], cookie['value'])  
+                    
+                logger.info("Loaded cookies from file")  
             except Exception as e:  
-                logger.warning(f"Session load failed: {str(e)}")  
-                
-        logger.info("Starting fresh login")  
-        time.sleep(random.uniform(1.0, 2.0))  # Small delay before login  
-        L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)  
+                logger.warning(f"Failed to load cookies: {str(e)}")  
         
-        if SESSION_FILE:  
-            L.save_session_to_file(SESSION_FILE)  
-            logger.info(f"Saved new session to {SESSION_FILE}")  
+        SESSION_LAST_REFRESH = datetime.now()  
         
-        return L  
-
-    except Exception as e:  
-        logger.error(f"Login failed: {str(e)}")  
-        raise HTTPException(  
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
-            detail="Instagram login failed"  
-        )  
+        # Try to log in if we have credentials  
+        if not any(c.name == 'sessionid' for c in SESSION.cookies) and INSTAGRAM_USERNAME and INSTAGRAM_PASSWORD:  
+            try:  
+                login_instagram()  
+            except Exception as e:  
+                logger.error(f"Login failed: {str(e)}")  
+    
+    return SESSION  
 
-def handle_instagram_errors(func):  
-    @wraps(func)  
-    async def wrapper(*args, **kwargs):  
-        # Extract username if present  
-        username = ""  
-        if len(args) > 1 and hasattr(args[1], '__str__'):  
-            username = str(args[1])  
-            
-        try:  
-            # Check for rate limiting  
-            if username and is_rate_limited(username):  
-                # Try to serve from cache  
-                cached = get_cached_stories(username)  
-                if cached:  
-                    return {**cached, "from_cache": True}  
-                else:  
-                    raise HTTPException(  
-                        status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                        detail="Rate limit exceeded. Please try again later."  
-                    )  
-            
-            # Execute the handler  
-            response = await func(*args, **kwargs)  
+def save_cookies():  
+    """Save session cookies to file"""  
+    if SESSION is None:  
+        return  
+        
+    try:  
+        cookies = []  
+        for cookie in SESSION.cookies:  
+            cookies.append({  
+                'name': cookie.name,  
+                'value': cookie.value,  
+                'domain': cookie.domain,  
+                'path': cookie.path  
+            })  
             
-            # Cache successful responses  
-            if username and isinstance(response, dict) and "data" in response:  
-                save_to_cache(username, response)  
-                
-            return response  
+        with open(COOKIE_FILE, 'w') as f:  
+            json.dump(cookies, f)  
             
-        except instaloader.exceptions.ConnectionException as e:  
-            error_message = str(e)  
-            logger.error(f"Connection error: {error_message}")  
+        logger.info("Saved cookies to file")  
+    except Exception as e:  
+        logger.warning(f"Failed to save cookies: {str(e)}")  
+
+def login_instagram():  
+    """Log in to Instagram"""  
+    if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:  
+        logger.error("Instagram credentials not configured")  
+        raise Exception("Instagram credentials required")  
+        
+    session = get_instagram_session()  
+    
+    # First get the login page to get the CSRF token  
+    try:  
+        resp = session.get('https://www.instagram.com/accounts/login/')  
+        time.sleep(random.uniform(1, 3))  
+        
+        # Extract CSRF token  
+        csrf_token = None  
+        match = re.search(r'"csrf_token":"(.*?)"', resp.text)  
+        if match:  
+            csrf_token = match.group(1)  
+        
+        if not csrf_token:  
+            raise Exception("Failed to get CSRF token")  
             
-            # Handle rate limiting errors  
-            if "429 Too Many Requests" in error_message:  
-                retry_mins = 30  # Default  
-                try:  
-                    # Try to extract minutes from error message  
-                    if "retried in" in error_message and "minutes" in error_message:  
-                        retry_text = error_message.split("retried in")[1].split("minutes")[0].strip()  
-                        retry_mins = int(retry_text)  
-                except:  
-                    pass  
-                
-                if username:  
-                    set_cooldown(username, retry_mins)  
-                    
-                # Try to serve from cache  
-                if username:  
-                    cached = get_cached_stories(username)  
-                    if cached:  
-                        return {**cached, "from_cache": True}  
-                
-                raise HTTPException(  
-                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                    detail=f"Instagram rate limit exceeded. Please try again in {retry_mins} minutes."  
-                )  
-                
-            elif "404 Not Found" in error_message:  
-                raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,   
-                                   detail="Profile or stories not found")  
+        # Prepare login data  
+        login_data = {  
+            'username': INSTAGRAM_USERNAME,  
+            'enc_password': f'#PWD_INSTAGRAM_BROWSER:0:{int(time.time())}:{INSTAGRAM_PASSWORD}',  
+            'queryParams': {},  
+            'optIntoOneTap': 'false',  
+            'csrfmiddlewaretoken': csrf_token  
+        }  
+        
+        # Update headers for the login request  
+        session.headers.update({  
+            'X-CSRFToken': csrf_token,  
+            'X-Requested-With': 'XMLHttpRequest',  
+            'Referer': 'https://www.instagram.com/accounts/login/',  
+            'Origin': 'https://www.instagram.com'  
+        })  
+        
+        # Wait a bit before login  
+        time.sleep(random.uniform(2, 4))  
+        
+        # Submit login  
+        login_resp = session.post(  
+            'https://www.instagram.com/accounts/login/ajax/',   
+            data=login_data  
+        )  
+        
+        login_json = login_resp.json()  
+        
+        # Check login status  
+        if login_json.get('authenticated') and login_json.get('status') == 'ok':  
+            logger.info("Successfully logged in to Instagram")  
+            save_cookies()  
+            return True  
+        else:  
+            logger.error(f"Login failed: {login_json}")  
+            if 'two_factor_required' in login_json:  
+                raise Exception("Two-factor authentication required")  
             else:  
-                raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
-                                   detail="Instagram service unavailable")  
+                raise Exception("Login failed")  
                 
-        except Exception as e:  
-            logger.error(f"Error: {str(e)}")  
-            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
-                               detail="Internal server error")  
-    return wrapper  
+    except Exception as e:  
+        logger.error(f"Login error: {str(e)}")  
+        raise  
 
-@app.get("/stories/{username}")  
-@handle_instagram_errors  
-async def get_stories(username: str, background_tasks: BackgroundTasks, cached: bool = False):  
-    """Retrieve Instagram stories for a user"""  
-    logger.info(f"Request for @{username} stories")  
+def get_user_stories(username):  
+    """Get stories for a username using the mobile API"""  
+    if is_rate_limited(username):  
+        cached = get_cached_stories(username)  
+        if cached:  
+            return cached  
+        raise Exception(f"Rate limited for {username}")  
     
-    # Return from cache if requested  
-    if cached:  
-        cached_result = get_cached_stories(username)  
-        if cached_result:  
-            return {**cached_result, "from_cache": True}  
+    session = get_instagram_session()  
     
     try:  
-        # Get Instagram loader  
-        L = get_instaloader()  
-        logger.info("Instagram loader ready")  
-        
-        # Small delay  
-        time.sleep(random.uniform(1.0, 2.0))  
-        
-        # Get profile  
-        logger.info(f"Fetching profile for {username}")  
-        try:  
-            profile = instaloader.Profile.from_username(L.context, username)  
-        except Exception as e:  
-            logger.error(f"Profile fetch error: {str(e)}")  
-            raise  
-            
-        # Check story access  
-        if not profile.has_viewable_story:  
-            logger.warning("No viewable story")  
-            raise HTTPException(  
-                status_code=status.HTTP_404_NOT_FOUND,  
-                detail="No accessible stories for this user"  
-            )  
-            
-        # Get stories  
-        logger.info("Fetching stories")  
+        # First, get the user ID  
+        user_id = None  
+        encoded_username = quote(username)  
+        
+        # Using the web API to get user info  
+        user_info_url = f"https://www.instagram.com/api/v1/users/web_profile_info/?username={encoded_username}"  
+        
+        session.headers.update({  
+            'X-IG-App-ID': '936619743392459',  # Common App ID  
+            'X-ASBD-ID': '198387',  
+            'X-IG-WWW-Claim': '0',  
+            'X-Requested-With': 'XMLHttpRequest',  
+            'Referer': f'https://www.instagram.com/{username}/',  
+        })  
+        
+        # Random delay to look more like a real user  
+        time.sleep(random.uniform(1, 2))  
+        
+        user_response = session.get(user_info_url)  
+        user_data = user_response.json()  
+        
+        if user_data.get('status') != 'ok':  
+            if 'message' in user_data and 'wait' in user_data['message'].lower():  
+                set_rate_limit(username, 30)  
+                raise Exception(f"Rate limited: {user_data.get('message')}")  
+            else:  
+                raise Exception(f"Failed to get user info: {user_data}")  
+        
+        user_id = user_data['data']['user']['id']  
+        logger.info(f"Got user ID for {username}: {user_id}")  
+        
+        # Now get the stories  
+        # Small delay between requests  
+        time.sleep(random.uniform(2, 3))  
+        
+        # Get the stories  
+        stories_url = f"https://i.instagram.com/api/v1/feed/user/{user_id}/story/"  
+        
+        stories_response = session.get(stories_url)  
+        stories_data = stories_response.json()  
+        
+        if stories_data.get('reel') is None:  
+            raise Exception("No stories found or private account")  
+        
+        # Process the stories  
         stories = []  
-        for story in L.get_stories(userids=[profile.userid]):  
-            for item in story.get_items():  
-                story_data = {  
-                    "id": str(item.mediaid),  
-                    "url": item.url,  
-                    "type": "video" if item.is_video else "image",  
-                    "timestamp": item.date_utc.isoformat()  
-                }  
-                
-                # Safe attribute access  
-                if item.is_video and hasattr(item, 'view_count'):  
-                    try:  
-                        story_data["views"] = item.view_count  
-                    except:  
-                        pass  
-                        
-                stories.append(story_data)  
-                
-        if not stories:  
-            logger.info("No stories found")  
-            raise HTTPException(  
-                status_code=status.HTTP_404_NOT_FOUND,  
-                detail="No active stories available"  
-            )  
+        items = stories_data.get('reel', {}).get('items', [])  
+        
+        for item in items:  
+            story = {  
+                "id": item.get('id', ''),  
+                "type": "video" if item.get('media_type') == 2 else "image",  
+                "timestamp": datetime.fromtimestamp(item.get('taken_at')).isoformat()  
+            }  
             
-        # Save session in background to not delay response  
-        background_tasks.add_task(lambda: L.save_session_to_file(SESSION_FILE) if SESSION_FILE else None)  
+            # Get media URL  
+            if story["type"] == "video":  
+                # Find the best video version  
+                if 'video_versions' in item:  
+                    videos = item['video_versions']  
+                    if videos:  
+                        # Get highest quality video  
+                        story["url"] = videos[0]['url']  
+                        # Add view count if available  
+                        if 'view_count' in item:  
+                            story["views"] = item['view_count']  
+            else:  
+                # Find the best image version  
+                if 'image_versions2' in item:  
+                    images = item['image_versions2']['candidates']  
+                    if images:  
+                        # Get highest quality image  
+                        story["url"] = images[0]['url']  
+            
+            stories.append(story)  
         
-        logger.info(f"Returning {len(stories)} stories")  
         result = {  
             "data": stories,  
             "count": len(stories),  
@@ -305,13 +335,77 @@ async def get_stories(username: str, background_tasks: BackgroundTasks, cached:
         }  
         
         return result  
-        
+    
     except Exception as e:  
-        logger.error(f"Error: {str(e)}")  
+        logger.error(f"Error getting stories: {str(e)}")  
+        if 'rate' in str(e).lower() or 'wait' in str(e).lower():  
+            set_rate_limit(username, 30)  
         raise  
 
+@app.get("/stories/{username}")  
+async def get_stories(username: str, cached: bool = False):  
+    """Get Instagram stories for a user"""  
+    logger.info(f"Request for @{username} stories")  
+    
+    # Return from cache if requested or available  
+    if cached:  
+        cached_result = get_cached_stories(username)  
+        if cached_result:  
+            return {**cached_result, "from_cache": True}  
+    
+    try:  
+        # Check for rate limiting  
+        if is_rate_limited(username):  
+            cached_result = get_cached_stories(username)  
+            if cached_result:  
+                return {**cached_result, "from_cache": True, "rate_limited": True}  
+            else:  
+                raise HTTPException(  
+                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                    detail="Rate limit exceeded for this username. Please try again later."  
+                )  
+        
+        # Get the stories  
+        result = get_user_stories(username)  
+        
+        # Cache the successful result  
+        save_to_cache(username, result)  
+        
+        return result  
+        
+    except Exception as e:  
+        error_message = str(e)  
+        logger.error(f"Error getting stories: {error_message}")  
+        
+        # Check for cached version if there's an error  
+        cached_result = get_cached_stories(username)  
+        if cached_result:  
+            logger.info(f"Returning cached result due to error")  
+            return {**cached_result, "from_cache": True, "error_occurred": True}  
+        
+        # Handle specific errors  
+        if 'rate' in error_message.lower() or 'wait' in error_message.lower():  
+            raise HTTPException(  
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                detail="Instagram rate limit exceeded. Please try again later."  
+            )  
+        elif 'private' in error_message.lower() or 'no stories' in error_message.lower():  
+            raise HTTPException(  
+                status_code=status.HTTP_404_NOT_FOUND,  
+                detail="No stories found or private account"  
+            )  
+        elif 'login' in error_message.lower() or 'credentials' in error_message.lower():  
+            raise HTTPException(  
+                status_code=status.HTTP_401_UNAUTHORIZED,  
+                detail="Authentication error"  
+            )  
+        else:  
+            raise HTTPException(  
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
+                detail="Error fetching stories"  
+            )  
+
 @app.get("/download/{url:path}")  
-@handle_instagram_errors  
 async def download_media(url: str):  
     """Download and proxy media content"""  
     logger.info(f"Download request for URL")  
@@ -325,6 +419,7 @@ async def download_media(url: str):
             )  
             
         # Configure request  
+        session = get_instagram_session()  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
             "Referer": "https://www.instagram.com/",  
@@ -332,7 +427,7 @@ async def download_media(url: str):
         }  
         
         # Get media  
-        response = requests.get(url, headers=headers, stream=True, timeout=15)  
+        response = session.get(url, headers=headers, stream=True, timeout=15)  
         response.raise_for_status()  
         
         # Determine content type  
@@ -390,4 +485,9 @@ def load_cache_from_disk():
 # Health check endpoint  
 @app.get("/health")  
 async def health_check():  
-    return {"status": "ok", "timestamp": datetime.now().isoformat()}
+    return {  
+        "status": "ok",   
+        "timestamp": datetime.now().isoformat(),  
+        "cache_size": len(STORY_CACHE),  
+        "rate_limits": len(RATE_LIMITS)  
+    }