Update app.py

app.py

@@ -7,8 +7,8 @@ import logging
 import random  
 import json  
 from datetime import datetime, timedelta  
+import hashlib  
 import re  
-import base64  
 from urllib.parse import quote  
 
 # Configure logging  
@@ -20,8 +20,13 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI(title="Instagram Stories API", docs_url=None, redoc_url=None)  
 
+# Environment variables  
+INSTAGRAM_USERNAME = os.getenv('INSTAGRAM_USERNAME')  
+INSTAGRAM_PASSWORD = os.getenv('INSTAGRAM_PASSWORD')  
+
 # Configuration  
 CACHE_DIR = "/tmp/instagram_cache"  
+COOKIE_FILE = "/tmp/instagram_cookies.json"  
 os.makedirs(CACHE_DIR, exist_ok=True)  
 
 # Cache state  
@@ -29,11 +34,16 @@ STORY_CACHE = {}
 CACHE_EXPIRY = {}  
 RATE_LIMITS = {}  
 
+# Session state  
+SESSION = None  
+SESSION_LAST_REFRESH = None  
+
 # User agents  
 USER_AGENTS = [  
     "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) 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):  
@@ -94,176 +104,242 @@ def set_rate_limit(username, minutes=15):
     }  
     logger.warning(f"Setting rate limit for {username} for {minutes} minutes")  
 
-def get_random_delay():  
-    """Get a random delay time to mimic human behavior"""  
-    return random.uniform(1, 3)  
-
-def fetch_stories_from_web(username):  
-    """Fetch stories using the public web interface"""  
-    url = f"https://storiesig.info/api/ig/stories/{username}"  
+def get_instagram_session():  
+    """Get or create an Instagram session"""  
+    global SESSION, SESSION_LAST_REFRESH  
     
-    try:  
-        session = requests.Session()  
-        session.headers.update({  
+    # 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': 'application/json, text/plain, */*',  
+            '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',  
-            'Referer': f'https://storiesig.info/stories/{username}',  
-            'Origin': 'https://storiesig.info',  
-            'Sec-Fetch-Dest': 'empty',  
-            'Sec-Fetch-Mode': 'cors',  
-            'Sec-Fetch-Site': 'same-origin',  
+            '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',  
         })  
         
-        # Add random delay to mimic human behavior  
-        time.sleep(get_random_delay())  
-        
-        response = session.get(url)  
+        # Load cookies if available  
+        if os.path.exists(COOKIE_FILE):  
+            try:  
+                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"Failed to load cookies: {str(e)}")  
         
-        if response.status_code == 429:  
-            logger.warning(f"Rate limited by storiesig.info for {username}")  
-            set_rate_limit(username, 10)  
-            raise Exception("Rate limited by service")  
-            
-        response.raise_for_status()  
-        data = response.json()  
+        SESSION_LAST_REFRESH = datetime.now()  
         
-        if not data.get('stories'):  
-            logger.warning(f"No stories found for {username}")  
-            raise Exception("No stories found")  
+        # 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 save_cookies():  
+    """Save session cookies to file"""  
+    if SESSION is None:  
+        return  
         
-        # Process the stories  
-        stories = []  
-        for item in data.get('stories', []):  
-            story = {  
-                "id": item.get('id', ''),  
-                "type": item.get('type', 'image'),  
-                "timestamp": datetime.fromtimestamp(item.get('taken_at_timestamp', 0)).isoformat(),  
-                "url": item.get('url', '')  
-            }  
+    try:  
+        cookies = []  
+        for cookie in SESSION.cookies:  
+            cookies.append({  
+                'name': cookie.name,  
+                'value': cookie.value,  
+                'domain': cookie.domain,  
+                'path': cookie.path  
+            })  
             
-            # Add thumbnail if available  
-            if item.get('thumbnail_url'):  
-                story["thumbnail"] = item.get('thumbnail_url')  
-                
-            stories.append(story)  
-        
-        result = {  
-            "data": stories,  
-            "count": len(stories),  
-            "username": username,  
-            "fetched_at": datetime.now().isoformat()  
-        }  
-        
-        return result  
-        
+        with open(COOKIE_FILE, 'w') as f:  
+            json.dump(cookies, f)  
+            
+        logger.info("Saved cookies to file")  
     except Exception as e:  
-        logger.error(f"Error fetching stories from web: {str(e)}")  
-        raise  
+        logger.warning(f"Failed to save cookies: {str(e)}")  
 
-def fetch_stories_from_alternative(username):  
-    """Try an alternative source for stories"""  
-    url = f"https://instastories.watch/api/stories/{username}"  
+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:  
-        session = requests.Session()  
-        session.headers.update({  
-            'User-Agent': random.choice(USER_AGENTS),  
-            'Accept': 'application/json',  
-            'Referer': f'https://instastories.watch/stories/{username}/',  
-            'Origin': 'https://instastories.watch'  
-        })  
+        resp = session.get('https://www.instagram.com/accounts/login/')  
+        time.sleep(random.uniform(1, 3))  
         
-        # Add random delay  
-        time.sleep(get_random_delay())  
+        # Extract CSRF token  
+        csrf_token = None  
+        match = re.search(r'"csrf_token":"(.*?)"', resp.text)  
+        if match:  
+            csrf_token = match.group(1)  
         
-        response = session.get(url)  
-        response.raise_for_status()  
-        data = response.json()  
+        if not csrf_token:  
+            raise Exception("Failed to get CSRF token")  
+            
+        # 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  
+        }  
         
-        if not data or not data.get('stories'):  
-            logger.warning(f"No stories found for {username} on alternative source")  
-            raise Exception("No stories found")  
+        # 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'  
+        })  
         
-        # Process the stories  
-        stories = []  
-        for item in data.get('stories', []):  
-            story = {  
-                "id": item.get('id', ''),  
-                "type": "video" if item.get('is_video', False) else "image",  
-                "timestamp": datetime.fromtimestamp(item.get('taken_at', 0)).isoformat(),  
-                "url": item.get('media_url', '')  
-            }  
-            
-            if item.get('thumbnail_url'):  
-                story["thumbnail"] = item.get('thumbnail_url')  
-                
-            stories.append(story)  
+        # Wait a bit before login  
+        time.sleep(random.uniform(2, 4))  
         
-        result = {  
-            "data": stories,  
-            "count": len(stories),  
-            "username": username,  
-            "fetched_at": datetime.now().isoformat()  
-        }  
+        # Submit login  
+        login_resp = session.post(  
+            'https://www.instagram.com/accounts/login/ajax/',   
+            data=login_data  
+        )  
         
-        return result  
+        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 Exception("Login failed")  
+                
     except Exception as e:  
-        logger.error(f"Error fetching stories from alternative: {str(e)}")  
+        logger.error(f"Login error: {str(e)}")  
         raise  
 
-def fetch_stories_from_third_source(username):  
-    """Try a third source for stories"""  
-    url = f"https://instasupersave.com/api/ig/stories/{username}"  
+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}")  
+    
+    session = get_instagram_session()  
     
     try:  
-        session = requests.Session()  
+        # 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({  
-            'User-Agent': random.choice(USER_AGENTS),  
-            'Accept': 'application/json',  
-            'Referer': f'https://instasupersave.com/instagram-stories/{username}/',  
-            'Origin': 'https://instasupersave.com'  
+            '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}/',  
         })  
         
-        # Add random delay  
-        time.sleep(get_random_delay())  
+        # Random delay to look more like a real user  
+        time.sleep(random.uniform(1, 2))  
         
-        response = session.get(url)  
-        response.raise_for_status()  
-        data = response.json()  
+        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}")  
         
-        if not data or not data.get('result') or not data['result'].get('stories'):  
-            logger.warning(f"No stories found for {username} on third source")  
-            raise Exception("No stories found")  
+        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 item in data['result'].get('stories', []):  
+        items = stories_data.get('reel', {}).get('items', [])  
+        
+        for item in items:  
             story = {  
                 "id": item.get('id', ''),  
-                "type": "video" if item.get('is_video', False) else "image",  
-                "timestamp": datetime.fromtimestamp(item.get('taken_at', 0)).isoformat(),  
-                "url": item.get('source', '')  
+                "type": "video" if item.get('media_type') == 2 else "image",  
+                "timestamp": datetime.fromtimestamp(item.get('taken_at')).isoformat()  
             }  
             
-            if item.get('thumbnail'):  
-                story["thumbnail"] = item.get('thumbnail')  
-                
+            # 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)  
         
         result = {  
             "data": stories,  
             "count": len(stories),  
             "username": username,  
-            "fetched_at": datetime.now().isoformat(),  
-            "source": "third"  
+            "fetched_at": datetime.now().isoformat()  
         }  
         
         return result  
-        
+    
     except Exception as e:  
-        logger.error(f"Error fetching stories from third source: {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}")  
@@ -289,58 +365,14 @@ async def get_stories(username: str, cached: bool = False):
                     detail="Rate limit exceeded for this username. Please try again later."  
                 )  
         
-        # Try multiple sources in sequence  
-        result = None  
-        sources_tried = 0  
-        error_messages = []  
-        
-        # Try first source  
-        try:  
-            sources_tried += 1  
-            result = fetch_stories_from_web(username)  
-        except Exception as e:  
-            error_messages.append(f"Source 1: {str(e)}")  
-            # Let's try the second source  
-            try:  
-                sources_tried += 1  
-                time.sleep(get_random_delay())  # Add delay between attempts  
-                result = fetch_stories_from_alternative(username)  
-            except Exception as e2:  
-                error_messages.append(f"Source 2: {str(e2)}")  
-                # Let's try the third source  
-                try:  
-                    sources_tried += 1  
-                    time.sleep(get_random_delay())  
-                    result = fetch_stories_from_third_source(username)  
-                except Exception as e3:  
-                    error_messages.append(f"Source 3: {str(e3)}")  
-        
-        if result:  
-            # Cache the successful result  
-            save_to_cache(username, result)  
-            result["sources_tried"] = sources_tried  
-            return result  
-        
-        # All sources failed, check cache  
-        cached_result = get_cached_stories(username)  
-        if cached_result:  
-            logger.info(f"All sources failed, returning cached result")  
-            return {  
-                **cached_result,   
-                "from_cache": True,   
-                "sources_tried": sources_tried,  
-                "errors": error_messages  
-            }  
+        # Get the stories  
+        result = get_user_stories(username)  
         
-        # No result from any source and no cache  
-        raise HTTPException(  
-            status_code=status.HTTP_404_NOT_FOUND,  
-            detail=f"Stories not found after trying {sources_tried} sources"  
-        )  
+        # Cache the successful result  
+        save_to_cache(username, result)  
+        
+        return result  
         
-    except HTTPException:  
-        # Re-raise HTTP exceptions directly  
-        raise  
     except Exception as e:  
         error_message = str(e)  
         logger.error(f"Error getting stories: {error_message}")  
@@ -352,15 +384,20 @@ async def get_stories(username: str, cached: bool = False):
             return {**cached_result, "from_cache": True, "error_occurred": True}  
         
         # Handle specific errors  
-        if 'rate' in error_message.lower() or 'limit' in error_message.lower():  
+        if 'rate' in error_message.lower() or 'wait' in error_message.lower():  
             raise HTTPException(  
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                detail="Rate limit exceeded. Please try again later."  
+                detail="Instagram rate limit exceeded. Please try again later."  
             )  
-        elif 'no stories' in error_message.lower():  
+        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 for this user"  
+                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(  
@@ -371,18 +408,18 @@ async def get_stories(username: str, cached: bool = False):
 @app.get("/download/{url:path}")  
 async def download_media(url: str):  
     """Download and proxy media content"""  
-    logger.info(f"Download request for media")  
+    logger.info(f"Download request for URL")  
     
     try:  
         # Validate URL  
-        if not url.startswith(("https://", "http://")):  
+        if not url.startswith(("https://instagram", "https://scontent")):  
             raise HTTPException(  
                 status_code=status.HTTP_400_BAD_REQUEST,  
                 detail="Invalid URL format"  
             )  
             
         # Configure request  
-        session = requests.Session()  
+        session = get_instagram_session()  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
             "Referer": "https://www.instagram.com/",