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,7 @@ 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  
 
 # Configure logging  
 logging.basicConfig(  
@@ -30,73 +25,21 @@ INSTAGRAM_PASSWORD = os.getenv('INSTAGRAM_PASSWORD')
 # Session configuration  
 SESSION_DIR = "/tmp/instagram_sessions"  
 SESSION_FILE = os.path.join(SESSION_DIR, f"session-{INSTAGRAM_USERNAME}") if INSTAGRAM_USERNAME else None  
-CACHE_DIR = "/tmp/instagram_cache"  
 
-# Create required directories  
+# Create session directory if not exists  
 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 = {}  
 
 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()  
-
-# 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)  
-    
-    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)  
-    
-    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")  
-    try:  
-        with open(cache_file, 'w') as f:  
-            json.dump({  
-                "data": stories_data,  
-                "expires": CACHE_EXPIRY[cache_key].isoformat()  
-            }, f)  
-    except Exception as e:  
-        logger.warning(f"Failed to save cache to disk: {str(e)}")  
-
-def get_instaloader(force_login=False) -> instaloader.Instaloader:  
+def get_instaloader() -> instaloader.Instaloader:  
     """Create and configure Instaloader instance with proper parameters"""  
     L = instaloader.Instaloader(  
         sleep=True,  
@@ -120,58 +63,27 @@ def get_instaloader(force_login=False) -> instaloader.Instaloader:
         )  
 
     try:  
-        if not force_login and SESSION_FILE and os.path.exists(SESSION_FILE):  
+        if SESSION_FILE and os.path.exists(SESSION_FILE):  
             logger.info(f"Attempting to load 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  
+        # Add delay before login  
         time.sleep(random.uniform(1.0, 3.0))  
                 
         logger.info("Starting fresh login process")  
         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))  
         raise HTTPException(  
@@ -179,75 +91,46 @@ def get_instaloader(force_login=False) -> instaloader.Instaloader:
             detail="Instagram login service unavailable"  
         )  
 
-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  
+# Check for cached stories  
+def get_cached_stories(username):  
+    if username in STORY_CACHE and username in CACHE_EXPIRY:  
+        if datetime.now() < CACHE_EXPIRY[username]:  
+            logger.info(f"Cache hit for {username}")  
+            return STORY_CACHE[username]  
         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")  
+            # Expired cache  
+            logger.info(f"Cache expired for {username}")  
+            STORY_CACHE.pop(username, None)  
+            CACHE_EXPIRY.pop(username, None)  
+    return None  
+
+# Save stories to cache  
+def cache_stories(username, stories_data, ttl_minutes=15):  
+    STORY_CACHE[username] = stories_data  
+    CACHE_EXPIRY[username] = datetime.now() + timedelta(minutes=ttl_minutes)  
+    logger.info(f"Cached stories for {username} for {ttl_minutes} minutes")  
 
 def handle_instagram_errors(func):  
     @wraps(func)  
     async def wrapper(*args, **kwargs):  
-        # Extract username from request path  
-        request_username = ""  
-        if len(args) > 1 and hasattr(args[1], '__str__'):  
-            request_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}  
-                else:  
-                    # No cache available  
-                    raise HTTPException(  
-                        status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
-                        detail="Rate limit exceeded. Please try again later."  
-                    )  
+            # Extract username if present  
+            request_username = ""  
+            if len(args) > 1 and hasattr(args[1], '__str__'):  
+                request_username = str(args[1])  
                 
+            # Check cache if it's a username request  
+            if request_username:  
+                cached_data = get_cached_stories(request_username)  
+                if cached_data:  
+                    return {**cached_data, "from_cache": True}  
+            
+            # If not in cache, proceed with request  
             response = await func(*args, **kwargs)  
             
-            # Cache successful responses if they contain story data  
+            # Cache successful username responses  
             if request_username and isinstance(response, dict) and "data" in response:  
-                await cache_stories(request_username, response)  
+                cache_stories(request_username, response)  
                 
             return response  
             
@@ -255,77 +138,31 @@ def handle_instagram_errors(func):
             error_message = str(e)  
             logger.error("Connection error: %s", error_message)  
             
-            # Check for rate limit related messages  
-            retry_after = None  
+            # Check for rate limit error  
             if "429 Too Many Requests" in error_message:  
-                # Extract retry timer from error message if possible  
+                # Try to extract retry time  
+                retry_minutes = 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}  
+                    retry_minutes = 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."  
+                    detail=f"Instagram rate limit exceeded. Please try again in {retry_minutes} 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)  
-                    
-                # 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}  
-                        
+            elif "401 Unauthorized" in error_message:  
                 raise HTTPException(  
                     status_code=status.HTTP_429_TOO_MANY_REQUESTS,  
                     detail="Instagram rate limit exceeded. Please try again later."  
                 )  
-            elif "404 Not Found" in error_message:  
-                raise HTTPException(  
-                    status_code=status.HTTP_404_NOT_FOUND,   
-                    detail="Profile not found or no stories available"  
-                )  
             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)  
-                
-            # 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(  
@@ -340,119 +177,86 @@ async def get_stories(username: str, background_tasks: BackgroundTasks, cached:
     """Retrieve stories with enhanced anti-detection measures"""  
     logger.info(f"Processing request for @{username}")  
     
-    # Check for cache first if requested  
+    # If cached param is true, only return from cache  
     if cached:  
-        cached_response = await get_cached_stories(username)  
+        cached_response = get_cached_stories(username)  
         if cached_response:  
             return {**cached_response, "from_cache": True}  
+        else:  
+            logger.info("No cache available for requested username")  
     
     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  
-            
-            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"  
-                )  
+        L = get_instaloader()  
+        logger.info("Instaloader instance configured")  
+        
+        # Randomized delay before profile request  
+        time.sleep(random.uniform(1.0, 2.0))  
+        
+        # Profile lookup  
+        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  
+        
+        logger.info(f"Profile found: {profile.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))  
-            
-            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)  
-                        
-            except instaloader.exceptions.QueryReturnedNotFoundException:  
-                logger.error("Stories not found")  
-                raise HTTPException(  
-                    status.HTTP_404_NOT_FOUND,  
-                    "Stories not available"  
-                )  
+        # Additional delay before story fetch   
+        time.sleep(random.uniform(1.0, 2.0))  
+        
+        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(),  
+                    }  
+                    
+                    # 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)  
+                    
+        except Exception as e:  
+            logger.error(f"Story fetch error: {str(e)}")  
+            raise  
 
-            if not stories:  
-                logger.info("No active stories found")  
-                raise HTTPException(  
-                    status.HTTP_404_NOT_FOUND,  
-                    "No active stories 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))  
-            
-            logger.info(f"Returning {len(stories)} stories")  
-            return {  
-                "data": stories,   
-                "count": len(stories),   
-                "username": username,  
-                "fetched_at": datetime.now().isoformat()  
-            }  
+        # Save session in background  
+        background_tasks.add_task(lambda: L.save_session_to_file(SESSION_FILE) if SESSION_FILE else None)  
         
-        # Execute in thread pool to not block the event loop  
-        return await run_in_threadpool(fetch_stories)  
+        logger.info(f"Returning {len(stories)} stories")  
+        result = {  
+            "data": stories,   
+            "count": len(stories),   
+            "username": username,  
+            "fetched_at": datetime.now().isoformat()  
+        }  
+        
+        return result  
 
     except Exception as e:  
         logger.error(f"Critical failure: {str(e)}")  
@@ -465,37 +269,28 @@ async def download_media(url: str):
     logger.info(f"Download request for: {url}")  
     
     try:  
-        # Basic validation to prevent arbitrary URL access  
+        # Basic validation  
         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))  
+        # Random delay  
+        time.sleep(random.uniform(0.5, 1.0))  
         
-        # Configure headers to mimic a browser  
+        # Configure headers  
         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",  
+            "Referer": "https://www.instagram.com/"  
         }  
         
-        # Request the media with a session  
-        session = requests.Session()  
-        response = session.get(url, headers=headers, stream=True, timeout=10)  
+        # Request the media  
+        response = requests.get(url, headers=headers, stream=True, timeout=10)  
         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")):  
@@ -511,15 +306,10 @@ async def download_media(url: str):
         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,  
@@ -529,43 +319,4 @@ async def download_media(url: str):
 # 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  
-@app.on_event("startup")  
-async def load_cache_from_disk():  
-    try:  
-        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:  
-                        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  
-                except Exception as e:  
-                    logger.warning(f"Failed to load cache file {filename}: {str(e)}")  
-        
-        logger.info(f"Loaded {len(STORY_CACHE)} items from cache")  
-    except Exception as e:  
-        logger.error(f"Error loading cache: {str(e)}")
+    return {"status": "ok", "timestamp": datetime.now().isoformat()}