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,13 +20,8 @@ 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  
@@ -34,16 +29,11 @@ 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) Version/17.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"  
 ]  
 
 def get_cache_key(username):  
@@ -104,242 +94,176 @@ def set_rate_limit(username, minutes=15):
     }  
     logger.warning(f"Setting rate limit for {username} for {minutes} minutes")  
 
-def get_instagram_session():  
-    """Get or create an Instagram session"""  
-    global SESSION, SESSION_LAST_REFRESH  
+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}"  
     
-    # 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({  
+    try:  
+        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': 'application/json, text/plain, */*',  
             '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',  
+            'Referer': f'https://storiesig.info/stories/{username}',  
+            'Origin': 'https://storiesig.info',  
+            'Sec-Fetch-Dest': 'empty',  
+            'Sec-Fetch-Mode': 'cors',  
+            'Sec-Fetch-Site': 'same-origin',  
         })  
         
-        # 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)}")  
+        # Add random delay to mimic human behavior  
+        time.sleep(get_random_delay())  
         
-        SESSION_LAST_REFRESH = datetime.now()  
-        
-        # 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  
+        response = session.get(url)  
         
-    try:  
-        cookies = []  
-        for cookie in SESSION.cookies:  
-            cookies.append({  
-                'name': cookie.name,  
-                'value': cookie.value,  
-                'domain': cookie.domain,  
-                'path': cookie.path  
-            })  
-            
-        with open(COOKIE_FILE, 'w') as f:  
-            json.dump(cookies, f)  
+        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")  
             
-        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))  
+        response.raise_for_status()  
+        data = response.json()  
         
-        # Extract CSRF token  
-        csrf_token = None  
-        match = re.search(r'"csrf_token":"(.*?)"', resp.text)  
-        if match:  
-            csrf_token = match.group(1)  
+        if not data.get('stories'):  
+            logger.warning(f"No stories found for {username}")  
+            raise Exception("No stories found")  
         
-        if not csrf_token:  
-            raise Exception("Failed to get CSRF token")  
+        # 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', '')  
+            }  
             
-        # 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  
+            # 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()  
         }  
         
-        # Update headers for the login request  
+        return result  
+        
+    except Exception as e:  
+        logger.error(f"Error fetching stories from web: {str(e)}")  
+        raise  
+
+def fetch_stories_from_alternative(username):  
+    """Try an alternative source for stories"""  
+    url = f"https://instastories.watch/api/stories/{username}"  
+    
+    try:  
+        session = requests.Session()  
         session.headers.update({  
-            'X-CSRFToken': csrf_token,  
-            'X-Requested-With': 'XMLHttpRequest',  
-            'Referer': 'https://www.instagram.com/accounts/login/',  
-            'Origin': 'https://www.instagram.com'  
+            'User-Agent': random.choice(USER_AGENTS),  
+            'Accept': 'application/json',  
+            'Referer': f'https://instastories.watch/stories/{username}/',  
+            'Origin': 'https://instastories.watch'  
         })  
         
-        # Wait a bit before login  
-        time.sleep(random.uniform(2, 4))  
+        # Add random delay  
+        time.sleep(get_random_delay())  
         
-        # Submit login  
-        login_resp = session.post(  
-            'https://www.instagram.com/accounts/login/ajax/',   
-            data=login_data  
-        )  
+        response = session.get(url)  
+        response.raise_for_status()  
+        data = response.json()  
         
-        login_json = login_resp.json()  
+        if not data or not data.get('stories'):  
+            logger.warning(f"No stories found for {username} on alternative source")  
+            raise Exception("No stories found")  
         
-        # 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")  
+        # 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)  
+        
+        result = {  
+            "data": stories,  
+            "count": len(stories),  
+            "username": username,  
+            "fetched_at": datetime.now().isoformat()  
+        }  
+        
+        return result  
+        
     except Exception as e:  
-        logger.error(f"Login error: {str(e)}")  
+        logger.error(f"Error fetching stories from alternative: {str(e)}")  
         raise  
 
-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()  
+def fetch_stories_from_third_source(username):  
+    """Try a third source for stories"""  
+    url = f"https://instasupersave.com/api/ig/stories/{username}"  
     
     try:  
-        # 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 = requests.Session()  
         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}/',  
+            'User-Agent': random.choice(USER_AGENTS),  
+            'Accept': 'application/json',  
+            'Referer': f'https://instasupersave.com/instagram-stories/{username}/',  
+            'Origin': 'https://instasupersave.com'  
         })  
         
-        # 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}")  
+        # Add random delay  
+        time.sleep(get_random_delay())  
         
-        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()  
+        response = session.get(url)  
+        response.raise_for_status()  
+        data = response.json()  
         
-        if stories_data.get('reel') is None:  
-            raise Exception("No stories found or private account")  
+        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")  
         
         # Process the stories  
         stories = []  
-        items = stories_data.get('reel', {}).get('items', [])  
-        
-        for item in items:  
+        for item in data['result'].get('stories', []):  
             story = {  
                 "id": item.get('id', ''),  
-                "type": "video" if item.get('media_type') == 2 else "image",  
-                "timestamp": datetime.fromtimestamp(item.get('taken_at')).isoformat()  
+                "type": "video" if item.get('is_video', False) else "image",  
+                "timestamp": datetime.fromtimestamp(item.get('taken_at', 0)).isoformat(),  
+                "url": item.get('source', '')  
             }  
             
-            # 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']  
-            
+            if item.get('thumbnail'):  
+                story["thumbnail"] = item.get('thumbnail')  
+                
             stories.append(story)  
         
         result = {  
             "data": stories,  
             "count": len(stories),  
             "username": username,  
-            "fetched_at": datetime.now().isoformat()  
+            "fetched_at": datetime.now().isoformat(),  
+            "source": "third"  
         }  
         
         return result  
-    
+        
     except Exception as 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)  
+        logger.error(f"Error fetching stories from third source: {str(e)}")  
         raise  
 
 @app.get("/stories/{username}")  
@@ -365,14 +289,58 @@ async def get_stories(username: str, cached: bool = False):
                     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)  
+        # 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  
+            }  
         
-        return result  
+        # 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"  
+        )  
         
+    except HTTPException:  
+        # Re-raise HTTP exceptions directly  
+        raise  
     except Exception as e:  
         error_message = str(e)  
         logger.error(f"Error getting stories: {error_message}")  
@@ -384,20 +352,15 @@ 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 'wait' in error_message.lower():  
+        if 'rate' in error_message.lower() or 'limit' in error_message.lower():  
             raise HTTPException(  
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                detail="Instagram rate limit exceeded. Please try again later."  
+                detail="Rate limit exceeded. Please try again later."  
             )  
-        elif 'private' in error_message.lower() or 'no stories' in error_message.lower():  
+        elif '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"  
+                detail="No stories found for this user"  
             )  
         else:  
             raise HTTPException(  
@@ -408,18 +371,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 URL")  
+    logger.info(f"Download request for media")  
     
     try:  
         # Validate URL  
-        if not url.startswith(("https://instagram", "https://scontent")):  
+        if not url.startswith(("https://", "http://")):  
             raise HTTPException(  
                 status_code=status.HTTP_400_BAD_REQUEST,  
                 detail="Invalid URL format"  
             )  
             
         # Configure request  
-        session = get_instagram_session()  
+        session = requests.Session()  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
             "Referer": "https://www.instagram.com/",