Update app.py

app.py

@@ -7,7 +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  
@@ -26,39 +27,15 @@ os.makedirs(CACHE_DIR, exist_ok=True)
 # Cache state  
 STORY_CACHE = {}  
 CACHE_EXPIRY = {}  
-LAST_REQUEST = {}  
+RATE_LIMITS = {}  
 
 # User agents  
 USER_AGENTS = [  
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1",  
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",  
-    "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 (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"  
 ]  
 
-# More diverse demo content for better user experience  
-DEMO_STORIES = {  
-    "type1": [  
-        {"id": "nature1", "type": "image", "url": "https://images.unsplash.com/photo-1682687980961-78fa83781450"},  
-        {"id": "nature2", "type": "image", "url": "https://images.unsplash.com/photo-1709921233257-4d6fad0af5c8"}  
-    ],  
-    "type2": [  
-        {"id": "city1", "type": "image", "url": "https://images.unsplash.com/photo-1710319367362-089a828a423c"},  
-        {"id": "city2", "type": "video", "url": "https://assets.mixkit.co/videos/preview/mixkit-aerial-view-of-city-traffic-at-night-11-large.mp4"}  
-    ],  
-    "type3": [  
-        {"id": "food1", "type": "image", "url": "https://images.unsplash.com/photo-1710170883104-2e9ac8709bb7"},  
-        {"id": "food2", "type": "image", "url": "https://images.unsplash.com/photo-1683009427500-71a13c0dce20"}  
-    ],  
-    "type4": [  
-        {"id": "travel1", "type": "image", "url": "https://images.unsplash.com/photo-1682687982501-1e58ab814714"},  
-        {"id": "travel2", "type": "video", "url": "https://assets.mixkit.co/videos/preview/mixkit-going-down-a-curved-highway-through-a-mountain-range-41576-large.mp4"}  
-    ],  
-    "type5": [  
-        {"id": "people1", "type": "image", "url": "https://images.unsplash.com/photo-1710161380135-9b617884d65f"},  
-        {"id": "people2", "type": "video", "url": "https://assets.mixkit.co/videos/preview/mixkit-man-dancing-under-changing-lights-1240-large.mp4"}  
-    ]  
-}  
-
 def get_cache_key(username):  
     """Generate a cache key from username"""  
     return username.lower()  
@@ -76,8 +53,8 @@ def get_cached_stories(username):
             CACHE_EXPIRY.pop(key, None)  
     return None  
 
-def save_to_cache(username, data, minutes=60):  
-    """Save stories to cache with a longer cache time"""  
+def save_to_cache(username, data, minutes=30):  
+    """Save stories to cache"""  
     key = get_cache_key(username)  
     STORY_CACHE[key] = data  
     CACHE_EXPIRY[key] = datetime.now() + timedelta(minutes=minutes)  
@@ -94,137 +71,203 @@ def save_to_cache(username, data, minutes=60):
     except Exception as e:  
         logger.warning(f"Failed to save cache: {str(e)}")  
 
-def should_rate_limit_request(username):  
-    """Basic rate limiting check"""  
+def is_rate_limited(username):  
+    """Check if we should rate limit this request"""  
+    # Check rate limits  
     key = username.lower()  
-    now = datetime.now()  
-    
-    if key in LAST_REQUEST:  
-        seconds_since = (now - LAST_REQUEST[key]).total_seconds()  
-        if seconds_since < 60:  # 1 minute between requests  
-            logger.warning(f"Rate limiting {username}: {seconds_since:.1f}s since last request")  
+    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  
-    
-    LAST_REQUEST[key] = now  
+        else:  
+            # Expired rate limit  
+            RATE_LIMITS.pop(key)  
     return False  
 
-def get_demo_stories(username):  
-    """Return demo stories for a username with deterministic but varied selection"""  
-    logger.info(f"Using demo stories for {username}")  
-    
-    # Use hash of username to deterministically select a demo type for each username  
-    # This ensures the same username always gets the same demo content  
-    hash_value = int(hashlib.md5(username.lower().encode()).hexdigest(), 16)  
-    demo_type = f"type{(hash_value % 5) + 1}"  # Get a number between 1-5  
-    
-    stories = DEMO_STORIES[demo_type]  
-    
-    # Add timestamps to make them seem fresh  
-    for story in stories:  
-        # Random time in the last 24 hours  
-        random_hours = random.uniform(0, 23)  
-        story_time = datetime.now() - timedelta(hours=random_hours)  
-        story["timestamp"] = story_time.isoformat()  
-    
-    result = {  
-        "data": stories,  
-        "count": len(stories),  
-        "username": username,  
-        "demo": True,  # Mark as demo content  
-        "note": "Using placeholder content - Instagram API access is currently restricted",  
-        "fetched_at": datetime.now().isoformat()  
+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  
     }  
-    
-    return result  
+    logger.warning(f"Setting rate limit for {username} for {minutes} minutes")  
 
-def try_get_real_stories(username):  
-    """Attempt to get real stories using multiple methods"""  
-    # Try method 1: Direct API (very likely to fail due to restrictions)  
+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}"  
+    
     try:  
-        logger.info(f"Attempting direct API access for {username}")  
-        url = f"https://i.instagram.com/api/v1/feed/user/{username}/story/"  
-        headers = {  
-            'User-Agent': 'Instagram 219.0.0.12.117 Android',  
-            'Accept-Language': 'en-US',  
-        }  
-        response = requests.get(url, headers=headers, timeout=5)  
-        
-        if response.status_code == 200:  
-            data = response.json()  
-            if 'reel' in data and 'items' in data['reel'] and data['reel']['items']:  
-                logger.info(f"Successfully got stories via direct API for {username}")  
-                # Process items and return  
-                stories = []  
-                for item in data['reel']['items']:  
-                    story = {  
-                        "id": item.get('pk', ''),  
-                        "type": "video" if item.get('media_type') == 2 else "image",  
-                        "timestamp": datetime.fromtimestamp(item.get('taken_at')).isoformat()  
-                    }  
-                    
-                    if story["type"] == "video" and 'video_versions' in item and item['video_versions']:  
-                        story["url"] = item['video_versions'][0]['url']  
-                    elif 'image_versions2' in item and 'candidates' in item['image_versions2'] and item['image_versions2']['candidates']:  
-                        story["url"] = item['image_versions2']['candidates'][0]['url']  
-                    else:  
-                        continue  # Skip if no URL  
-                        
-                    stories.append(story)  
+        session = requests.Session()  
+        session.headers.update({  
+            'User-Agent': random.choice(USER_AGENTS),  
+            'Accept': 'application/json, text/plain, */*',  
+            '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',  
+        })  
+        
+        # Add random delay to mimic human behavior  
+        time.sleep(get_random_delay())  
+        
+        response = session.get(url)  
+        
+        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()  
+        
+        if not data.get('stories'):  
+            logger.warning(f"No stories found for {username}")  
+            raise Exception("No stories found")  
+        
+        # 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', '')  
+            }  
+            
+            # Add thumbnail if available  
+            if item.get('thumbnail_url'):  
+                story["thumbnail"] = item.get('thumbnail_url')  
                 
-                if stories:  
-                    return {  
-                        "data": stories,  
-                        "count": len(stories),  
-                        "username": username,  
-                        "source": "instagram_api",  
-                        "fetched_at": datetime.now().isoformat()  
-                    }  
+            stories.append(story)  
+        
+        result = {  
+            "data": stories,  
+            "count": len(stories),  
+            "username": username,  
+            "fetched_at": datetime.now().isoformat()  
+        }  
+        
+        return result  
+        
     except Exception as e:  
-        logger.warning(f"Direct API access failed: {str(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 method 2: Unofficial service (if available)  
     try:  
-        logger.info(f"Attempting unofficial service for {username}")  
-        url = f"https://instagram-stories1.p.rapidapi.com/v1/get_stories?username={username}"  
-        headers = {  
-            "X-RapidAPI-Key": os.getenv('RAPIDAPI_KEY', ''),  # Set this in your environment if available  
-            "X-RapidAPI-Host": "instagram-stories1.p.rapidapi.com"  
-        }  
+        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'  
+        })  
         
-        if headers["X-RapidAPI-Key"]:  # Only try if API key is set  
-            response = requests.get(url, headers=headers, timeout=10)  
+        # Add random delay  
+        time.sleep(get_random_delay())  
+        
+        response = session.get(url)  
+        response.raise_for_status()  
+        data = response.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")  
+        
+        # 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 response.status_code == 200:  
-                data = response.json()  
-                if isinstance(data, dict) and 'stories' in data and data['stories']:  
-                    logger.info(f"Successfully got stories via unofficial service for {username}")  
-                    stories = []  
-                    
-                    for item in data['stories']:  
-                        story = {  
-                            "id": item.get('id', str(hash(item.get('media_url', '')))),  
-                            "type": item.get('media_type', 'image'),  
-                            "url": item.get('media_url', ''),  
-                            "timestamp": item.get('timestamp', datetime.now().isoformat())  
-                        }  
-                        stories.append(story)  
-                    
-                    if stories:  
-                        return {  
-                            "data": stories,  
-                            "count": len(stories),  
-                            "username": username,  
-                            "source": "unofficial_api",  
-                            "fetched_at": datetime.now().isoformat()  
-                        }  
+            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.warning(f"Unofficial service failed: {str(e)}")  
+        logger.error(f"Error fetching stories from alternative: {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}"  
     
-    # All methods failed  
-    return None  
+    try:  
+        session = requests.Session()  
+        session.headers.update({  
+            'User-Agent': random.choice(USER_AGENTS),  
+            'Accept': 'application/json',  
+            'Referer': f'https://instasupersave.com/instagram-stories/{username}/',  
+            'Origin': 'https://instasupersave.com'  
+        })  
+        
+        # Add random delay  
+        time.sleep(get_random_delay())  
+        
+        response = session.get(url)  
+        response.raise_for_status()  
+        data = response.json()  
+        
+        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 = []  
+        for item in data['result'].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('source', '')  
+            }  
+            
+            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(),  
+            "source": "third"  
+        }  
+        
+        return result  
+        
+    except Exception as e:  
+        logger.error(f"Error fetching stories from third source: {str(e)}")  
+        raise  
 
 @app.get("/stories/{username}")  
-async def get_stories(username: str, cached: bool = False, demo: bool = False):  
+async def get_stories(username: str, cached: bool = False):  
     """Get Instagram stories for a user"""  
     logger.info(f"Request for @{username} stories")  
     
@@ -234,42 +277,70 @@ async def get_stories(username: str, cached: bool = False, demo: bool = False):
         if cached_result:  
             return {**cached_result, "from_cache": True}  
     
-    # If demo parameter is specified, return demo stories  
-    if demo:  
-        demo_stories = get_demo_stories(username)  
-        return demo_stories  
-    
     try:  
-        # Check rate limiting  
-        if should_rate_limit_request(username):  
+        # 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:  
-                # If no cache but rate limited, use demo content  
-                demo_stories = get_demo_stories(username)  
-                save_to_cache(username, demo_stories, minutes=5)  # Short cache time for demo content  
-                return {**demo_stories, "rate_limited": True}  
+                raise HTTPException(  
+                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                    detail="Rate limit exceeded for this username. Please try again later."  
+                )  
         
-        # Try to get real stories  
-        real_stories = try_get_real_stories(username)  
+        # 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 real_stories:  
+        if result:  
             # Cache the successful result  
-            save_to_cache(username, real_stories)  
-            return real_stories  
+            save_to_cache(username, result)  
+            result["sources_tried"] = sources_tried  
+            return result  
         
-        # If no result, check cache  
+        # All sources failed, check cache  
         cached_result = get_cached_stories(username)  
         if cached_result:  
-            logger.info(f"No live stories found, returning cached result")  
-            return {**cached_result, "from_cache": True}  
+            logger.info(f"All sources failed, returning cached result")  
+            return {  
+                **cached_result,   
+                "from_cache": True,   
+                "sources_tried": sources_tried,  
+                "errors": error_messages  
+            }  
         
-        # No result and no cache, use demo content  
-        demo_stories = get_demo_stories(username)  
-        save_to_cache(username, demo_stories, minutes=30)  
-        return demo_stories  
+        # 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}")  
@@ -280,9 +351,22 @@ async def get_stories(username: str, cached: bool = False, demo: bool = False):
             logger.info(f"Returning cached result due to error")  
             return {**cached_result, "from_cache": True, "error_occurred": True}  
         
-        # No cache available, use demo content  
-        demo_stories = get_demo_stories(username)  
-        return {**demo_stories, "error_occurred": True}  
+        # Handle specific errors  
+        if 'rate' in error_message.lower() or 'limit' in error_message.lower():  
+            raise HTTPException(  
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
+                detail="Rate limit exceeded. Please try again later."  
+            )  
+        elif 'no stories' in error_message.lower():  
+            raise HTTPException(  
+                status_code=status.HTTP_404_NOT_FOUND,  
+                detail="No stories found for this user"  
+            )  
+        else:  
+            raise HTTPException(  
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
+                detail="Error fetching stories"  
+            )  
 
 @app.get("/download/{url:path}")  
 async def download_media(url: str):  
@@ -301,7 +385,7 @@ async def download_media(url: str):
         session = requests.Session()  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
-            "Referer": "https://www.google.com/",  
+            "Referer": "https://www.instagram.com/",  
             "Accept": "*/*",  
         }  
         
@@ -335,23 +419,6 @@ async def download_media(url: str):
             detail="Failed to download media"  
         )  
 
-# Add an endpoint to explain what's happening  
-@app.get("/")  
-async def root():  
-    return {  
-        "message": "Instagram Stories API",  
-        "status": "Running with demo mode",  
-        "note": "Due to Instagram's API restrictions, this service currently provides placeholder content.",  
-        "endpoints": {  
-            "get_stories": "/stories/{username}",  
-            "get_stories_from_cache": "/stories/{username}?cached=true",  
-            "get_demo_stories": "/stories/{username}?demo=true",  
-            "download_media": "/download/{url}",  
-            "health_check": "/health"  
-        },  
-        "timestamp": datetime.now().isoformat()  
-    }  
-
 # Load cache from disk at startup  
 @app.on_event("startup")  
 def load_cache_from_disk():  
@@ -383,8 +450,7 @@ def load_cache_from_disk():
 async def health_check():  
     return {  
         "status": "ok",   
-        "mode": "demo",  
-        "note": "Instagram access restricted - using placeholder content",  
         "timestamp": datetime.now().isoformat(),  
         "cache_size": len(STORY_CACHE),  
+        "rate_limits": len(RATE_LIMITS)  
     }