Update app.py

app.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI, HTTPException, status, BackgroundTasks, Request, Depends  
-from fastapi.responses import StreamingResponse, JSONResponse  
+from fastapi import FastAPI, HTTPException, status, BackgroundTasks  
+from fastapi.responses import StreamingResponse  
 import instaloader  
 import requests  
 import os  
@@ -7,12 +7,8 @@ import time
 import logging  
 import random  
 from functools import wraps  
-import json  
 from datetime import datetime, timedelta  
-from typing import Dict, List, Optional  
-import hashlib  
-import asyncio  
-from starlette.concurrency import run_in_threadpool  
+import json  
 
 # Configure logging  
 logging.basicConfig(  
@@ -36,68 +32,83 @@ CACHE_DIR = "/tmp/instagram_cache"
 os.makedirs(SESSION_DIR, exist_ok=True)  
 os.makedirs(CACHE_DIR, exist_ok=True)  
 
-# Rate limiting state  
-LAST_REQUEST_TIME = {}  
-COOLDOWN_PERIODS = {}  
-RATE_LIMIT_LOCK = asyncio.Lock()  
-
-# Cache state  
-STORY_CACHE: Dict[str, Dict] = {}  
-CACHE_EXPIRY: Dict[str, datetime] = {}  
-CACHE_LOCK = asyncio.Lock()  
+# Simple memory cache  
+STORY_CACHE = {}  
+CACHE_EXPIRY = {}  
+LAST_REQUEST = {}  
+COOLDOWN_UNTIL = {}  
 
 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 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1",  
-    "Mozilla/5.0 (iPad; CPU OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1"  
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"  
 ]  
 
-# Calculate cache key for a username  
-def get_cache_key(username: str) -> str:  
-    return hashlib.md5(username.lower().encode()).hexdigest()  
+def get_cache_key(username):  
+    """Simple cache key generator"""  
+    return username.lower()  
 
-# Check if we have a valid cache for a username  
-async def get_cached_stories(username: str) -> Optional[Dict]:  
-    cache_key = get_cache_key(username)  
-    
-    async with CACHE_LOCK:  
-        if cache_key in STORY_CACHE and cache_key in CACHE_EXPIRY:  
-            if datetime.now() < CACHE_EXPIRY[cache_key]:  
-                logger.info(f"Cache hit for {username}")  
-                return STORY_CACHE[cache_key]  
-            else:  
-                # Expired cache  
-                logger.info(f"Cache expired for {username}")  
-                STORY_CACHE.pop(cache_key, None)  
-                CACHE_EXPIRY.pop(cache_key, None)  
-    
+def get_cached_stories(username):  
+    """Get stories from cache if available"""  
+    key = get_cache_key(username)  
+    if key in STORY_CACHE and key in CACHE_EXPIRY:  
+        if datetime.now() < CACHE_EXPIRY[key]:  
+            logger.info(f"Cache hit for {username}")  
+            return STORY_CACHE[key]  
+        else:  
+            # Clean expired cache  
+            STORY_CACHE.pop(key, None)  
+            CACHE_EXPIRY.pop(key, None)  
     return None  
 
-# Save stories to cache  
-async def cache_stories(username: str, stories_data: Dict, ttl_minutes: int = 15):  
-    cache_key = get_cache_key(username)  
+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)  
     
-    async with CACHE_LOCK:  
-        STORY_CACHE[cache_key] = stories_data  
-        CACHE_EXPIRY[cache_key] = datetime.now() + timedelta(minutes=ttl_minutes)  
-        
-    logger.info(f"Cached stories for {username} for {ttl_minutes} minutes")  
-    
-    # Save to disk for persistence  
-    cache_file = os.path.join(CACHE_DIR, f"{cache_key}.json")  
+    # Save to disk  
     try:  
+        cache_file = os.path.join(CACHE_DIR, f"{key}.json")  
         with open(cache_file, 'w') as f:  
             json.dump({  
-                "data": stories_data,  
-                "expires": CACHE_EXPIRY[cache_key].isoformat()  
+                "data": data,  
+                "expires": CACHE_EXPIRY[key].isoformat()  
             }, f)  
+        logger.info(f"Cached {username} stories for {minutes} minutes")  
     except Exception as e:  
-        logger.warning(f"Failed to save cache to disk: {str(e)}")  
+        logger.warning(f"Failed to save cache: {str(e)}")  
+
+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")  
+            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()  
+    return False  
 
-def get_instaloader(force_login=False) -> instaloader.Instaloader:  
-    """Create and configure Instaloader instance with proper parameters"""  
+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 get_instaloader():  
+    """Create and configure Instaloader instance"""  
     L = instaloader.Instaloader(  
         sleep=True,  
         request_timeout=30,  
@@ -120,382 +131,211 @@ def get_instaloader(force_login=False) -> instaloader.Instaloader:
         )  
 
     try:  
-        if not force_login and SESSION_FILE and os.path.exists(SESSION_FILE):  
-            logger.info(f"Attempting to load session from {SESSION_FILE}")  
+        if SESSION_FILE and os.path.exists(SESSION_FILE):  
+            logger.info(f"Loading session from {SESSION_FILE}")  
             try:  
                 L.load_session_from_file(INSTAGRAM_USERNAME, SESSION_FILE)  
                 logger.info("Session loaded successfully")  
-                # Test session with a lightweight call if possible  
                 return L  
             except Exception as e:  
-                logger.warning(f"Session load failed: {str(e)}, performing fresh login")  
-                
-        # Add delay before login to mimic human behavior  
-        time.sleep(random.uniform(1.0, 3.0))  
+                logger.warning(f"Session load failed: {str(e)}")  
                 
-        logger.info("Starting fresh login process")  
+        logger.info("Starting fresh login")  
+        time.sleep(random.uniform(1.0, 2.0))  # Small delay before login  
         L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)  
         
-        # Set realistic headers  
-        L.context._session.headers.update({  
-            'Accept-Language': 'en-US,en;q=0.9',  
-            'Accept-Encoding': 'gzip, deflate, br',  
-            'Referer': 'https://www.instagram.com/',  
-            'Origin': 'https://www.instagram.com',  
-            'DNT': '1',  
-            'Connection': 'keep-alive',  
-            'Sec-Fetch-Dest': 'empty',  
-            'Sec-Fetch-Mode': 'cors',  
-            'Sec-Fetch-Site': 'same-origin',  
-            'Pragma': 'no-cache',  
-            'Cache-Control': 'no-cache',  
-        })  
-        
         if SESSION_FILE:  
             L.save_session_to_file(SESSION_FILE)  
             logger.info(f"Saved new session to {SESSION_FILE}")  
         
-        # Add delay after login  
-        time.sleep(random.uniform(2.0, 4.0))  
-        
         return L  
 
-    except instaloader.exceptions.BadCredentialsException as e:  
-        logger.error("Invalid credentials: %s", str(e))  
-        raise HTTPException(  
-            status_code=status.HTTP_401_UNAUTHORIZED,  
-            detail="Invalid Instagram credentials"  
-        )  
-    except instaloader.exceptions.TwoFactorAuthRequiredException as e:  
-        logger.error("2FA required: %s", str(e))  
-        raise HTTPException(  
-            status_code=status.HTTP_401_UNAUTHORIZED,  
-            detail="Two-factor authentication required"  
-        )  
     except Exception as e:  
-        logger.error("Login failed: %s", str(e))  
+        logger.error(f"Login failed: {str(e)}")  
         raise HTTPException(  
             status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
-            detail="Instagram login service unavailable"  
+            detail="Instagram login failed"  
         )  
 
-async def is_rate_limited(username: str) -> bool:  
-    """Check if a given username is currently rate limited"""  
-    async with RATE_LIMIT_LOCK:  
-        # If in cooldown period, check if it's expired  
-        if username in COOLDOWN_PERIODS:  
-            if datetime.now() < COOLDOWN_PERIODS[username]:  
-                remaining = (COOLDOWN_PERIODS[username] - datetime.now()).seconds  
-                logger.warning(f"User {username} in cooldown for {remaining} more seconds")  
-                return True  
-            else:  
-                # Cooldown expired  
-                del COOLDOWN_PERIODS[username]  
-        
-        # Check time since last request  
-        if username in LAST_REQUEST_TIME:  
-            elapsed = (datetime.now() - LAST_REQUEST_TIME[username]).seconds  
-            min_interval = 60  # Minimum 60 seconds between requests  
-            if elapsed < min_interval:  
-                logger.warning(f"Rate limiting {username}: {elapsed}s elapsed, need {min_interval}s")  
-                return True  
-        
-        # Update last request time  
-        LAST_REQUEST_TIME[username] = datetime.now()  
-        return False  
-
-async def handle_rate_limit_error(username: str, retry_after: Optional[int] = None):  
-    """Handle rate limit by setting cooldown period"""  
-    async with RATE_LIMIT_LOCK:  
-        # Set cooldown period based on retry_after or default logic  
-        if retry_after:  
-            # Use server-provided retry duration if available  
-            cooldown_minutes = max(retry_after / 60, 1)  # At least 1 minute  
-        else:  
-            # Default exponential backoff  
-            cooldown_minutes = 5  
-            if username in COOLDOWN_PERIODS:  
-                cooldown_minutes = min(cooldown_minutes * 2, 30)  # Up to 30 minutes  
-        
-        COOLDOWN_PERIODS[username] = datetime.now() + timedelta(minutes=cooldown_minutes)  
-        logger.warning(f"Setting cooldown for {username} for {cooldown_minutes} minutes")  
-
 def handle_instagram_errors(func):  
     @wraps(func)  
     async def wrapper(*args, **kwargs):  
-        # Extract username from request path  
-        request_username = ""  
+        # Extract username if present  
+        username = ""  
         if len(args) > 1 and hasattr(args[1], '__str__'):  
-            request_username = str(args[1])  
+            username = str(args[1])  
             
         try:  
             # Check for rate limiting  
-            if request_username and await is_rate_limited(request_username):  
-                cached_response = await get_cached_stories(request_username)  
-                if cached_response:  
-                    # Return cached response with cache note  
-                    logger.info(f"Returning cached response for rate-limited user {request_username}")  
-                    return {**cached_response, "from_cache": True}  
+            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:  
-                    # No cache available  
                     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)  
             
-            # Cache successful responses if they contain story data  
-            if request_username and isinstance(response, dict) and "data" in response:  
-                await cache_stories(request_username, response)  
+            # Cache successful responses  
+            if username and isinstance(response, dict) and "data" in response:  
+                save_to_cache(username, response)  
                 
             return response  
             
         except instaloader.exceptions.ConnectionException as e:  
             error_message = str(e)  
-            logger.error("Connection error: %s", error_message)  
+            logger.error(f"Connection error: {error_message}")  
             
-            # Check for rate limit related messages  
-            retry_after = None  
+            # Handle rate limiting errors  
             if "429 Too Many Requests" in error_message:  
-                # Extract retry timer from error message if possible  
+                retry_mins = 30  # Default  
                 try:  
-                    retry_text = error_message.split("retried in")[1].split("minutes")[0].strip()  
-                    retry_after = int(retry_text) * 60  # Convert to seconds  
-                except (IndexError, ValueError):  
-                    retry_after = 1800  # Default 30 minutes  
-                
-                if request_username:  
-                    await handle_rate_limit_error(request_username, retry_after)  
-                
-                # Try to serve from cache if available  
-                if request_username:  
-                    cached_response = await get_cached_stories(request_username)  
-                    if cached_response:  
-                        logger.info(f"Returning cached response for rate-limited request")  
-                        return {**cached_response, "from_cache": True}  
+                    # 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  
                 
-                raise HTTPException(  
-                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                    detail=f"Instagram rate limit exceeded. Please try again in {retry_after//60} minutes."  
-                )  
-            elif "401 Unauthorized" in error_message and "Please wait a few minutes" in error_message:  
-                if request_username:  
-                    await handle_rate_limit_error(request_username)  
+                if username:  
+                    set_cooldown(username, retry_mins)  
                     
-                # Try to serve from cache if available  
-                if request_username:  
-                    cached_response = await get_cached_stories(request_username)  
-                    if cached_response:  
-                        logger.info(f"Returning cached response for rate-limited request")  
-                        return {**cached_response, "from_cache": True}  
-                        
+                # 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="Instagram rate limit exceeded. Please try again later."  
+                    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 not found or no stories available"  
-                )  
+                raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,   
+                                   detail="Profile or stories not found")  
             else:  
-                raise HTTPException(  
-                    status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
-                    detail="Instagram service unavailable"  
-                )  
-                
-        except instaloader.exceptions.QueryReturnedBadRequestException as e:  
-            logger.error("API error 400: %s", str(e))  
-            if request_username:  
-                await handle_rate_limit_error(request_username)  
+                raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,  
+                                   detail="Instagram service unavailable")  
                 
-            # Try to serve from cache if available  
-            if request_username:  
-                cached_response = await get_cached_stories(request_username)  
-                if cached_response:  
-                    logger.info(f"Returning cached response for rate-limited request")  
-                    return {**cached_response, "from_cache": True}  
-                    
-            raise HTTPException(  
-                status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                detail="Instagram rate limit exceeded"  
-            )  
-            
-        except HTTPException:  
-            # Re-raise HTTP exceptions without modification  
-            raise  
-            
         except Exception as e:  
-            logger.error("Unexpected error: %s", str(e))  
-            raise HTTPException(  
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
-                detail="Internal server error"  
-            )  
+            logger.error(f"Error: {str(e)}")  
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,  
+                               detail="Internal server error")  
     return wrapper  
 
 @app.get("/stories/{username}")  
 @handle_instagram_errors  
 async def get_stories(username: str, background_tasks: BackgroundTasks, cached: bool = False):  
-    """Retrieve stories with enhanced anti-detection measures"""  
-    logger.info(f"Processing request for @{username}")  
+    """Retrieve Instagram stories for a user"""  
+    logger.info(f"Request for @{username} stories")  
     
-    # Check for cache first if requested  
+    # Return from cache if requested  
     if cached:  
-        cached_response = await get_cached_stories(username)  
-        if cached_response:  
-            return {**cached_response, "from_cache": True}  
+        cached_result = get_cached_stories(username)  
+        if cached_result:  
+            return {**cached_result, "from_cache": True}  
     
     try:  
-        # Run the Instagram operations in a thread pool to not block the event loop  
-        async def fetch_stories():  
-            # Get loader with session  
-            L = get_instaloader()  
-            logger.info("Instaloader instance configured")  
-            
-            # Randomized delay before profile request (more natural)  
-            delay = random.uniform(1.5, 3.0)  
-            logger.debug(f"Applying initial delay of {delay:.2f}s")  
-            time.sleep(delay)  
-            
-            # Profile lookup with retry  
-            profile = None  
-            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) * random.uniform(3.0, 5.0)  
-                    logger.warning(f"Rate limited, waiting {wait_time:.2f}s")  
-                    time.sleep(wait_time)  
-                except instaloader.exceptions.ConnectionException as e:  
-                    if "401 Unauthorized" in str(e) and "Please wait a few minutes" in str(e):  
-                        # Try with a fresh login if session might be expired  
-                        if attempt < 2:  # Only try this once  
-                            logger.warning("Session may be expired, trying with fresh login")  
-                            L = get_instaloader(force_login=True)  
-                            time.sleep(random.uniform(4.0, 6.0))  
-                            continue  
-                    raise  
+        # 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  
             
-            if profile is None:  
-                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_viewable_story:  
-                logger.warning("No viewable story")  
-                raise HTTPException(  
-                    status.HTTP_404_NOT_FOUND,  
-                    "No accessible stories for this profile"  
-                )  
-
-            # Additional delay before story fetch  
-            time.sleep(random.uniform(1.0, 2.5))  
+        # 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"  
+            )  
             
-            logger.info("Fetching stories")  
-            stories = []  
-            try:  
-                for story in L.get_stories(userids=[profile.userid]):  
-                    for item in story.get_items():  
-                        # Create a story dict with safe attribute access  
-                        story_data = {  
-                            "id": str(item.mediaid),  
-                            "url": item.url,  
-                            "type": "video" if item.is_video else "image",  
-                            "timestamp": item.date_utc.isoformat(),  
-                        }  
-                        
-                        # Add any available metadata safely  
-                        if hasattr(item, 'owner_username'):  
-                            story_data["username"] = item.owner_username  
-                            
-                        # Only try to add view_count if it's a video  
-                        if item.is_video:  
-                            try:  
-                                if hasattr(item, 'view_count'):  
-                                    story_data["views"] = item.view_count  
-                            except AttributeError:  
-                                pass  
-                        
-                        stories.append(story_data)  
+        # Get stories  
+        logger.info("Fetching 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  
                         
-            except instaloader.exceptions.QueryReturnedNotFoundException:  
-                logger.error("Stories not found")  
-                raise HTTPException(  
-                    status.HTTP_404_NOT_FOUND,  
-                    "Stories not available"  
-                )  
-
-            if not stories:  
-                logger.info("No active stories found")  
-                raise HTTPException(  
-                    status.HTTP_404_NOT_FOUND,  
-                    "No active stories available"  
-                )  
-
-            # Queue session save in background  
-            background_tasks.add_task(lambda: L.save_session_to_file(SESSION_FILE) if SESSION_FILE else None)  
-            
-            # Final randomized delay  
-            time.sleep(random.uniform(0.3, 0.7))  
+                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"  
+            )  
             
-            logger.info(f"Returning {len(stories)} stories")  
-            return {  
-                "data": stories,   
-                "count": len(stories),   
-                "username": username,  
-                "fetched_at": datetime.now().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)  
+        
+        logger.info(f"Returning {len(stories)} stories")  
+        result = {  
+            "data": stories,  
+            "count": len(stories),  
+            "username": username,  
+            "fetched_at": datetime.now().isoformat()  
+        }  
+        
+        return result  
         
-        # Execute in thread pool to not block the event loop  
-        return await run_in_threadpool(fetch_stories)  
-
     except Exception as e:  
-        logger.error(f"Critical failure: {str(e)}")  
+        logger.error(f"Error: {str(e)}")  
         raise  
 
 @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}")  
+    logger.info(f"Download request for URL")  
     
     try:  
-        # Basic validation to prevent arbitrary URL access  
+        # Validate URL  
         if not url.startswith(("https://instagram", "https://scontent")):  
             raise HTTPException(  
                 status_code=status.HTTP_400_BAD_REQUEST,  
                 detail="Invalid URL format"  
             )  
             
-        # Random delay to avoid detection patterns  
-        time.sleep(random.uniform(0.5, 1.5))  
-        
-        # Configure headers to mimic a browser  
+        # Configure request  
         headers = {  
             "User-Agent": random.choice(USER_AGENTS),  
-            "Accept": "*/*",  
-            "Accept-Language": "en-US,en;q=0.9",  
-            "Accept-Encoding": "gzip, deflate, br",  
             "Referer": "https://www.instagram.com/",  
-            "Origin": "https://www.instagram.com",  
-            "Sec-Fetch-Dest": "empty",  
-            "Sec-Fetch-Mode": "cors",  
-            "Sec-Fetch-Site": "cross-site",  
-            "Pragma": "no-cache",  
-            "Cache-Control": "no-cache",  
+            "Accept": "*/*",  
         }  
         
-        # Request the media with a session  
-        session = requests.Session()  
-        response = session.get(url, headers=headers, stream=True, timeout=10)  
+        # Get media  
+        response = requests.get(url, headers=headers, stream=True, timeout=15)  
         response.raise_for_status()  
         
-        # Determine content type from response or URL  
+        # Determine content type  
         if "Content-Type" in response.headers:  
             content_type = response.headers["Content-Type"]  
         elif url.endswith((".jpg", ".jpeg")):  
@@ -505,67 +345,49 @@ async def download_media(url: str):
         else:  
             content_type = "application/octet-stream"  
             
-        logger.info(f"Media downloaded successfully: {content_type}")  
+        logger.info(f"Media downloaded: {content_type}")  
         
-        # Stream the response back  
+        # Return the media  
         return StreamingResponse(  
             response.iter_content(chunk_size=8192),  
             media_type=content_type,  
-            headers={  
-                "Content-Disposition": f"attachment; filename={url.split('/')[-1]}",  
-                "Cache-Control": "no-cache, no-store, must-revalidate",  
-                "Pragma": "no-cache",  
-                "Expires": "0",  
-            }  
+            headers={"Content-Disposition": f"attachment; filename={url.split('/')[-1]}"}  
         )  
         
-    except requests.exceptions.RequestException as e:  
+    except Exception as e:  
         logger.error(f"Download failed: {str(e)}")  
         raise HTTPException(  
             status_code=status.HTTP_502_BAD_GATEWAY,  
             detail="Failed to download media"  
         )  
 
-# Add a health check endpoint  
-@app.get("/health")  
-async def health_check():  
-    return {"status": "ok", "timestamp": datetime.now().isoformat()}  
-
-# Add middleware to handle rate limit headers  
-@app.middleware("http")  
-async def add_rate_limit_headers(request: Request, call_next):  
-    response = await call_next(request)  
-    
-    # Add custom headers for rate limiting info  
-    username = request.path_params.get("username", None)  
-    if username and username in COOLDOWN_PERIODS:  
-        remaining = max(0, int((COOLDOWN_PERIODS[username] - datetime.now()).total_seconds()))  
-        response.headers["X-RateLimit-Reset"] = str(remaining)  
-        response.headers["X-RateLimit-Remaining"] = "0" if remaining > 0 else "1"  
-        
-    return response  
-
-# Startup event to load cache from disk  
+# Load cache from disk at startup  
 @app.on_event("startup")  
-async def load_cache_from_disk():  
+def load_cache_from_disk():  
     try:  
+        count = 0  
         for filename in os.listdir(CACHE_DIR):  
             if filename.endswith('.json'):  
-                file_path = os.path.join(CACHE_DIR, filename)  
                 try:  
-                    with open(file_path, 'r') as f:  
+                    with open(os.path.join(CACHE_DIR, filename), 'r') as f:  
                         cache_data = json.load(f)  
-                        
+                    
                     if "data" in cache_data and "expires" in cache_data:  
-                        expire_time = datetime.fromisoformat(cache_data["expires"])  
-                        if expire_time > datetime.now():  
-                            cache_key = filename[:-5]  # Remove .json  
-                            async with CACHE_LOCK:  
-                                STORY_CACHE[cache_key] = cache_data["data"]  
-                                CACHE_EXPIRY[cache_key] = expire_time  
+                        # Convert ISO string to datetime  
+                        expires = datetime.fromisoformat(cache_data["expires"])  
+                        if expires > datetime.now():  
+                            key = filename.replace('.json', '')  
+                            STORY_CACHE[key] = cache_data["data"]  
+                            CACHE_EXPIRY[key] = expires  
+                            count += 1  
                 except Exception as e:  
-                    logger.warning(f"Failed to load cache file {filename}: {str(e)}")  
+                    logger.warning(f"Couldn't load cache file {filename}: {e}")  
         
-        logger.info(f"Loaded {len(STORY_CACHE)} items from cache")  
+        logger.info(f"Loaded {count} items from cache")  
     except Exception as e:  
-        logger.error(f"Error loading cache: {str(e)}")
+        logger.error(f"Cache loading error: {e}")  
+
+# Health check endpoint  
+@app.get("/health")  
+async def health_check():  
+    return {"status": "ok", "timestamp": datetime.now().isoformat()}