inst

Sleeping

App Files Files Community

Chrunos commited on Apr 8, 2025

Commit

226ea29

verified ·

1 Parent(s): 633133c

Update app.py

Browse files

Files changed (1) hide show

app.py +350 -479

app.py CHANGED Viewed

@@ -1,7 +1,5 @@
-from fastapi import FastAPI, HTTPException, status, BackgroundTasks, Request, Form, Cookie, Depends
-from fastapi.responses import StreamingResponse, JSONResponse, HTMLResponse, RedirectResponse
-from fastapi.templating import Jinja2Templates
-from fastapi.staticfiles import StaticFiles
 import requests
 import os
 import time
@@ -10,10 +8,7 @@ import random
 import json
 from datetime import datetime, timedelta
 import re
-from urllib.parse import quote
 from typing import Optional
-import secrets
-from pathlib import Path
 # Configure logging
 logging.basicConfig(
@@ -24,178 +19,158 @@ logger = logging.getLogger(__name__)
 app = FastAPI(title="Instagram Stories API")
-# Create templates and static directories
-templates_dir = Path("templates")
-templates_dir.mkdir(exist_ok=True)
-static_dir = Path("static")
-static_dir.mkdir(exist_ok=True)
-# Create template files
-login_template = """
 <!DOCTYPE html>
 <html>
 <head>
-    <title>Instagram Login</title>
     <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 500px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        .container {
-            background-color: #fff;
-            border-radius: 8px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            padding: 25px;
-        }
-        h1 {
-            color: #262626;
-            text-align: center;
-        }
-        .form-group {
-            margin-bottom: 15px;
-        }
-        label {
-            display: block;
-            margin-bottom: 5px;
-            font-weight: bold;
-        }
-        input[type="text"], input[type="password"] {
-            width: 100%;
-            padding: 10px;
-            border: 1px solid #dbdbdb;
-            border-radius: 3px;
-            box-sizing: border-box;
-        }
-        .btn {
-            background-color: #0095f6;
-            border: none;
-            color: white;
-            padding: 10px 15px;
-            border-radius: 4px;
-            cursor: pointer;
-            font-weight: bold;
-            width: 100%;
-        }
-        .btn:hover {
-            background-color: #0086e0;
-        }
-        .status {
-            margin-top: 20px;
-            padding: 10px;
-            border-radius: 4px;
-        }
-        .success {
-            background-color: #e8f5e9;
-            color: #388e3c;
-        }
-        .error {
-            background-color: #ffebee;
-            color: #d32f2f;
-        }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>Instagram Login</h1>
-        <p>Enter your Instagram credentials to access the API. Your credentials are only used to establish a session and are not stored on the server.</p>
-        {% if message %}
-            <div class="status {% if success %}success{% else %}error{% endif %}">
-                {{ message }}
-            </div>
-        {% endif %}
-        <form method="post" action="/login">
-            <div class="form-group">
-                <label for="username">Username</label>
-                <input type="text" id="username" name="username" required>
             </div>
-            <div class="form-group">
-                <label for="password">Password</label>
-                <input type="password" id="password" name="password" required>
             </div>
-            <button type="submit" class="btn">Log In</button>
-        </form>
     </div>
 </body>
 </html>
 """
-status_template = """
 <!DOCTYPE html>
 <html>
 <head>
-    <title>Instagram API Status</title>
     <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 700px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        .container {
-            background-color: #fff;
-            border-radius: 8px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            padding: 25px;
-        }
-        h1, h2 {
-            color: #262626;
-        }
-        h1 {
-            text-align: center;
-        }
-        .status-badge {
-            display: inline-block;
-            padding: 5px 10px;
-            border-radius: 4px;
-            font-weight: bold;
-            margin-left: 10px;
-        }
-        .connected {
-            background-color: #e8f5e9;
-            color: #388e3c;
-        }
-        .disconnected {
-            background-color: #ffebee;
-            color: #d32f2f;
-        }
-        .info-box {
-            background-color: #f5f5f5;
-            border-radius: 4px;
-            padding: 15px;
-            margin: 15px 0;
-        }
-        .btn {
-            background-color: #0095f6;
-            border: none;
-            color: white;
-            padding: 10px 15px;
-            border-radius: 4px;
-            text-decoration: none;
-            display: inline-block;
-            margin-right: 10px;
-            margin-top: 10px;
-            font-weight: bold;
-        }
-        .btn:hover {
-            background-color: #0086e0;
-        }
-        table {
-            width: 100%;
-            border-collapse: collapse;
-            margin-top: 15px;
-        }
-        th, td {
-            text-align: left;
-            padding: 8px;
-            border-bottom: 1px solid #ddd;
-        }
-        th {
-            background-color: #f8f9fa;
-        }
     </style>
 </head>
 <body>
@@ -203,116 +178,54 @@ status_template = """
         <h1>Instagram API Status</h1>
         <h2>Connection Status
-            {% if session_valid %}
-                <span class="status-badge connected">Connected</span>
-            {% else %}
-                <span class="status-badge disconnected">Disconnected</span>
-            {% endif %}
         </h2>
-        <div class="info-box">
-            {% if session_valid %}
-                <p>✅ You are currently logged in as <strong>{{ username }}</strong></p>
-                <p>Session will expire: {{ session_expires }}</p>
-            {% else %}
-                <p>❌ No active Instagram session</p>
-                <p>Please login to use the API with full functionality</p>
-            {% endif %}
         </div>
-        <a href="/login" class="btn">{% if session_valid %}Re-Login{% else %}Login{% endif %}</a>
-        {% if session_valid %}
-            <a href="/logout" class="btn" style="background-color: #f44336;">Logout</a>
-        {% endif %}
         <h2>API Endpoints</h2>
         <table>
-            <tr>
-                <th>Endpoint</th>
-                <th>Description</th>
-            </tr>
-            <tr>
-                <td><code>/stories/{username}</code></td>
-                <td>Get stories for a user</td>
-            </tr>
-            <tr>
-                <td><code>/download/{url}</code></td>
-                <td>Download media from a URL</td>
-            </tr>
-            <tr>
-                <td><code>/status</code></td>
-                <td>View API status and session info</td>
-            </tr>
         </table>
-        {% if cache_info %}
-        <h2>Cache Status</h2>
-        <div class="info-box">
-            <p>Cached users: {{ cache_info.count }}</p>
-            <p>Total items: {{ cache_info.items }}</p>
         </div>
-        {% endif %}
     </div>
 </body>
 </html>
 """
-# Write templates to files
-with open(templates_dir / "login.html", "w") as f:
-    f.write(login_template)
-with open(templates_dir / "status.html", "w") as f:
-    f.write(status_template)
-# Set up templates and static files
-templates = Jinja2Templates(directory=str(templates_dir))
-app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
-# Configuration
-CACHE_DIR = "/tmp/instagram_cache"
-COOKIES_FILE = "/tmp/instagram_cookies.json"
-SESSION_KEY = secrets.token_hex(16)  # For securing session
-os.makedirs(CACHE_DIR, exist_ok=True)
-# Session and cache state
-IG_SESSION = None
-IG_SESSION_USERNAME = None
-IG_SESSION_EXPIRY = None
-STORY_CACHE = {}
-CACHE_EXPIRY = {}
-LAST_REQUEST = {}
-# 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"
-]
 def get_cache_key(username):
-    """Generate a cache key from username"""
     return username.lower()
 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
 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)
-    # Save to disk
     try:
         cache_file = os.path.join(CACHE_DIR, f"{key}.json")
         with open(cache_file, 'w') as f:
@@ -325,13 +238,12 @@ def save_to_cache(username, data, minutes=30):
         logger.warning(f"Failed to save cache: {str(e)}")
 def should_rate_limit_request(username):
-    """Basic rate limiting check"""
     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")
             return True
@@ -339,12 +251,9 @@ def should_rate_limit_request(username):
     return False
 def get_instagram_session():
-    """Get current Instagram session"""
     global IG_SESSION, IG_SESSION_EXPIRY
-    # Check if session is still valid
     if IG_SESSION is None or IG_SESSION_EXPIRY is None or datetime.now() > IG_SESSION_EXPIRY:
-        # Try to load from file
         if os.path.exists(COOKIES_FILE):
             try:
                 with open(COOKIES_FILE, 'r') as f:
@@ -353,7 +262,6 @@ def get_instagram_session():
                 if 'expires' in data and datetime.fromisoformat(data['expires']) > datetime.now():
                     IG_SESSION = requests.Session()
-                    # Set cookies
                     for cookie in data['cookies']:
                         IG_SESSION.cookies.set(
                             cookie['name'],
@@ -361,7 +269,6 @@ def get_instagram_session():
                             domain=cookie.get('domain', '.instagram.com')
                         )
-                    # Set expiry
                     IG_SESSION_EXPIRY = datetime.fromisoformat(data['expires'])
                     global IG_SESSION_USERNAME
                     IG_SESSION_USERNAME = data.get('username', 'unknown')
@@ -369,34 +276,31 @@ def get_instagram_session():
                     logger.info(f"Loaded Instagram session for {IG_SESSION_USERNAME}")
                     return IG_SESSION
                 else:
-                    logger.warning("Saved session expired, needs new login")
             except Exception as e:
                 logger.error(f"Failed to load cookies: {str(e)}")
-    # Return existing session if valid
     if IG_SESSION is not None and IG_SESSION_EXPIRY is not None and datetime.now() < IG_SESSION_EXPIRY:
         return IG_SESSION
     return None
-def save_instagram_session(session, username, days=7):
-    """Save Instagram session cookies"""
     global IG_SESSION, IG_SESSION_EXPIRY, IG_SESSION_USERNAME
-    IG_SESSION = session
     IG_SESSION_EXPIRY = datetime.now() + timedelta(days=days)
     IG_SESSION_USERNAME = username
     try:
-        cookies = []
-        for cookie in session.cookies:
-            cookies.append({
-                'name': cookie.name,
-                'value': cookie.value,
-                'domain': cookie.domain,
-                'path': cookie.path
-            })
         with open(COOKIES_FILE, 'w') as f:
             json.dump({
                 'cookies': cookies,
@@ -411,7 +315,6 @@ def save_instagram_session(session, username, days=7):
         return False
 def clear_instagram_session():
-    """Clear Instagram session"""
     global IG_SESSION, IG_SESSION_EXPIRY, IG_SESSION_USERNAME
     IG_SESSION = None
@@ -425,124 +328,46 @@ def clear_instagram_session():
         except Exception as e:
             logger.error(f"Failed to remove cookies file: {str(e)}")
-def login_to_instagram(username, password):
-    """Login to Instagram and save session"""
-    session = requests.Session()
-    # Set up headers for web request
-    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-Language': 'en-US,en;q=0.5',
-        'Accept-Encoding': 'gzip, deflate, br',
-        'DNT': '1',
-        'Connection': 'keep-alive',
-        'Upgrade-Insecure-Requests': '1',
-        'Sec-Fetch-Dest': 'document',
-        'Sec-Fetch-Mode': 'navigate',
-        'Sec-Fetch-Site': 'none',
-        'Sec-Fetch-User': '?1',
-    })
-    try:
-        # First get the login page to get CSRF token
-        response = session.get('https://www.instagram.com/accounts/login/')
-        # Wait a bit to look natural
-        time.sleep(random.uniform(1, 2))
-        # Extract CSRF token from response
-        csrf_token = None
-        match = re.search(r'"csrf_token":"(.*?)"', response.text)
-        if match:
-            csrf_token = match.group(1)
-        if not csrf_token:
-            raise Exception("Could not extract CSRF token")
-        # Update headers for login request
-        session.headers.update({
-            'X-CSRFToken': csrf_token,
-            'X-Instagram-AJAX': '1',
-            'X-Requested-With': 'XMLHttpRequest',
-            'Origin': 'https://www.instagram.com',
-            'Referer': 'https://www.instagram.com/accounts/login/',
-            'Content-Type': 'application/x-www-form-urlencoded'
-        })
-        # Prepare login data
-        # Convert password to Instagram's browser format
-        enc_password = f'#PWD_INSTAGRAM_BROWSER:0:{int(time.time())}:{password}'
-        login_data = {
-            'username': username,
-            'enc_password': enc_password,
-            'queryParams': '{}',
-            'optIntoOneTap': 'false'
-        }
-        # Wait a bit more to look natural
-        time.sleep(random.uniform(2, 3))
-        # Make login request
-        login_response = session.post(
-            'https://www.instagram.com/accounts/login/ajax/',
-            data=login_data
-        )
-        # Check login response
-        try:
-            login_json = login_response.json()
-            if login_json.get('authenticated') is True:
-                logger.info(f"Successfully logged in as {username}")
-                # Save session
-                if save_instagram_session(session, username):
-                    return {
-                        'success': True,
-                        'message': 'Login successful'
-                    }
-                else:
-                    return {
-                        'success': False,
-                        'message': 'Login successful but failed to save session'
-                    }
-            else:
-                if 'message' in login_json:
-                    logger.warning(f"Login failed: {login_json['message']}")
-                    return {
-                        'success': False,
-                        'message': f"Login failed: {login_json['message']}"
-                    }
-                elif 'error_type' in login_json:
-                    logger.warning(f"Login failed: {login_json['error_type']}")
-                    return {
-                        'success': False,
-                        'message': f"Login failed: {login_json['error_type']}"
-                    }
-                else:
-                    logger.warning("Login failed: Unknown reason")
-                    return {
-                        'success': False,
-                        'message': 'Login failed for unknown reason'
-                    }
-        except Exception as e:
-            logger.error(f"Failed to parse login response: {str(e)}")
-            return {
-                'success': False,
-                'message': 'Failed to parse login response'
-            }
-    except Exception as e:
-        logger.error(f"Login error: {str(e)}")
-        return {
-            'success': False,
-            'message': f"Login error: {str(e)}"
-        }
 def get_instagram_stories(username):
-    """Get user's stories using the authenticated session"""
     session = get_instagram_session()
     if not session:
         logger.warning("No valid Instagram session")
@@ -554,69 +379,47 @@ def get_instagram_stories(username):
         session.headers.update({
             'User-Agent': random.choice(USER_AGENTS),
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'X-IG-App-ID': '936619743392459',  # This ID is important
-            'X-ASBD-ID': '198387',
-            'X-IG-WWW-Claim': '0',
-            'Origin': 'https://www.instagram.com',
-            'Connection': 'keep-alive',
             'Referer': f'https://www.instagram.com/{username}/',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'TE': 'trailers',
         })
-        # Get user profile
         profile_response = session.get(profile_url)
         if profile_response.status_code != 200:
             logger.warning(f"Failed to get user profile: {profile_response.status_code}")
-            if profile_response.status_code == 401:
-                # Try to extract the message
-                try:
-                    resp_data = profile_response.json()
-                    if 'message' in resp_data:
-                        logger.warning(f"API error: {resp_data['message']}")
-                        if "wait" in resp_data['message'].lower():
-                            return {"error": "rate_limited", "message": resp_data['message']}
-                except:
-                    pass
-                return {"error": "unauthorized", "message": "Unauthorized access - session may be expired"}
-            return {"error": "profile_fetch_failed", "status": profile_response.status_code}
         profile_data = profile_response.json()
         if 'data' not in profile_data or 'user' not in profile_data['data']:
-            logger.warning("User profile data not found")
-            return {"error": "profile_not_found", "message": "User profile data not found"}
         user_id = profile_data['data']['user']['id']
-        # Small delay
         time.sleep(random.uniform(1, 2))
-        # Now get the stories
         stories_url = f"https://www.instagram.com/api/v1/feed/user/{user_id}/story/"
         stories_response = session.get(stories_url)
         if stories_response.status_code != 200:
-            logger.warning(f"Failed to get stories: {stories_response.status_code}")
-            return {"error": "stories_fetch_failed", "status": stories_response.status_code}
         stories_data = stories_response.json()
-        # Check if there are stories
         if 'reel' not in stories_data or not stories_data['reel'].get('items'):
-            logger.info(f"No stories found for {username}")
-            return {"error": "no_stories", "message": "No stories found for this user"}
-        # Process stories
         stories = []
         for item in stories_data['reel']['items']:
             story = {
@@ -629,20 +432,18 @@ def get_instagram_stories(username):
             if story["type"] == "video" and 'video_versions' in item and item['video_versions']:
                 story["url"] = item['video_versions'][0]['url']
-                # Add view count if available
                 if 'view_count' in item:
                     story["views"] = item['view_count']
             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)
         if not stories:
-            logger.info(f"No valid stories found for {username}")
-            return {"error": "no_valid_stories", "message": "No valid stories found for this user"}
         result = {
             "data": stories,
@@ -657,79 +458,167 @@ def get_instagram_stories(username):
         logger.error(f"Error getting stories: {str(e)}")
         return {"error": "exception", "message": str(e)}
 @app.get("/", response_class=HTMLResponse)
-async def root(request: Request):
-    """Redirect to status page"""
     return RedirectResponse(url="/status")
-@app.get("/login", response_class=HTMLResponse)
-async def login_page(request: Request, message: str = None, success: bool = False):
-    """Login page"""
-    return templates.TemplateResponse(
-        "login.html",
-        {"request": request, "message": message, "success": success}
-    )
-@app.post("/login")
-async def login_process(request: Request, username: str = Form(...), password: str = Form(...)):
-    """Process login form"""
-    logger.info(f"Login attempt for {username}")
-    result = login_to_instagram(username, password)
-    if result['success']:
-        return RedirectResponse(url="/status", status_code=303)
-    else:
-        return templates.TemplateResponse(
-            "login.html",
-            {
-                "request": request,  # Now using the actual request object
-                "message": result['message'],
-                "success": False
-            }
-        )
 @app.get("/logout")
 async def logout():
-    """Logout and clear session"""
     clear_instagram_session()
     return RedirectResponse(url="/status", status_code=303)
 @app.get("/status", response_class=HTMLResponse)
-async def status_page(request: Request):
-    """Status page"""
     session = get_instagram_session()
     session_valid = session is not None
-    cache_info = {
-        "count": len(STORY_CACHE),
-        "items": sum(len(data.get("data", [])) for data in STORY_CACHE.values())
-    }
-    return templates.TemplateResponse(
-        "status.html",
-        {
-            "request": request,
-            "session_valid": session_valid,
-            "username": IG_SESSION_USERNAME,
-            "session_expires": IG_SESSION_EXPIRY.strftime("%Y-%m-%d %H:%M:%S") if IG_SESSION_EXPIRY else None,
-            "cache_info": cache_info
-        }
-    )
 @app.get("/stories/{username}")
-async def get_stories(username: str, cached: bool = False, demo: bool = False):
-    """Get Instagram stories for a user"""
     logger.info(f"Request for @{username} stories")
-    # Return from cache if requested
     if cached:
         cached_result = get_cached_stories(username)
         if cached_result:
             return {**cached_result, "from_cache": True}
     try:
-        # Check for rate limiting
         if should_rate_limit_request(username):
             cached_result = get_cached_stories(username)
             if cached_result:
@@ -740,38 +629,35 @@ async def get_stories(username: str, cached: bool = False, demo: bool = False):
                     detail="Rate limit exceeded. Please try again later."
                 )
-        # Get stories
         result = get_instagram_stories(username)
         if not result:
-            # No session or other error
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="No valid Instagram session. Please login first."
             )
         if "error" in result:
-            # Handle specific errors
-            if result["error"] == "rate_limited":
                 cached_result = get_cached_stories(username)
                 if cached_result:
-                    return {**cached_result, "from_cache": True, "rate_limited": True}
                 raise HTTPException(
                     status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                    detail=result.get("message", "Rate limit exceeded. Please try again later.")
                 )
-            elif result["error"] == "unauthorized":
                 raise HTTPException(
-                    status_code=status.HTTP_401_UNAUTHORIZED,
-                    detail=result.get("message", "Unauthorized. Please login again.")
                 )
-            elif result["error"] == "no_stories":
                 raise HTTPException(
                     status_code=status.HTTP_404_NOT_FOUND,
-                    detail=result.get("message", "No stories found for this user.")
                 )
             else:
@@ -780,56 +666,43 @@ async def get_stories(username: str, cached: bool = False, demo: bool = False):
                     detail=result.get("message", "Failed to get stories")
                 )
-        # Cache the result
         save_to_cache(username, result)
         return result
     except HTTPException:
-        # Re-raise HTTP exceptions
         raise
     except Exception as e:
         logger.error(f"Error: {str(e)}")
-        # Check for cached version if there's an error
         cached_result = get_cached_stories(username)
         if cached_result:
             return {**cached_result, "from_cache": True, "error_occurred": True}
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Error getting stories: {str(e)}"
         )
 @app.get("/download/{url:path}")
 async def download_media(url: str):
-    """Download and proxy media content"""
     logger.info(f"Download request for media")
     try:
-        # Validate URL
         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() or requests.Session()
         headers = {
             "User-Agent": random.choice(USER_AGENTS),
-            "Accept": "*/*",
-            "Accept-Language": "en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate, br",
             "Referer": "https://www.instagram.com/",
-            "Origin": "https://www.instagram.com"
         }
-        # Get media
         response = session.get(url, headers=headers, stream=True, timeout=15)
         response.raise_for_status()
-        # Determine content type
         if "Content-Type" in response.headers:
             content_type = response.headers["Content-Type"]
         elif url.endswith((".jpg", ".jpeg")):
@@ -841,7 +714,6 @@ async def download_media(url: str):
         logger.info(f"Media downloaded: {content_type}")
-        # Return the media
         return StreamingResponse(
             response.iter_content(chunk_size=8192),
             media_type=content_type,
@@ -868,7 +740,6 @@ def startup_event():
                         cache_data = json.load(f)
                     if "data" in cache_data and "expires" in cache_data:
-                        # Convert ISO string to datetime
                         expires = datetime.fromisoformat(cache_data["expires"])
                         if expires > datetime.now():
                             key = filename.replace('.json', '')

+from fastapi import FastAPI, HTTPException, status, Request, Form
+from fastapi.responses import StreamingResponse, HTMLResponse, RedirectResponse
 import requests
 import os
 import time
 import json
 from datetime import datetime, timedelta
 import re
 from typing import Optional
 # Configure logging
 logging.basicConfig(
 app = FastAPI(title="Instagram Stories API")
+# Configuration
+CACHE_DIR = "/tmp/instagram_cache"
+COOKIES_FILE = "/tmp/instagram_cookies.json"
+os.makedirs(CACHE_DIR, exist_ok=True)
+# Instagram session state
+IG_SESSION = None
+IG_SESSION_USERNAME = None
+IG_SESSION_EXPIRY = None
+STORY_CACHE = {}
+CACHE_EXPIRY = {}
+LAST_REQUEST = {}
+# 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"
+]
+# Cookie import HTML template
+COOKIE_IMPORT_HTML = """
 <!DOCTYPE html>
 <html>
 <head>
+    <title>Import Instagram Session</title>
     <style>
+        body { font-family: Arial; max-width: 700px; margin: 0 auto; padding: 20px; }
+        .container { background-color: #fff; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); padding: 25px; }
+        h1 { color: #262626; text-align: center; }
+        .form-group { margin-bottom: 15px; }
+        label { display: block; margin-bottom: 10px; }
+        textarea { width: 100%; padding: 10px; border: 1px solid #dbdbdb; border-radius: 3px; height: 150px; }
+        .btn { background-color: #0095f6; border: none; color: white; padding: 10px 15px; border-radius: 4px; cursor: pointer; font-weight: bold; }
+        .btn-block { width: 100%%; }
+        .status { margin-top: 20px; padding: 10px; border-radius: 4px; }
+        .success { background-color: #e8f5e9; color: #388e3c; }
+        .error { background-color: #ffebee; color: #d32f2f; }
+        .instructions { background-color: #f8f9fa; padding: 15px; border-radius: 4px; margin-bottom: 20px; }
+        .code { font-family: monospace; background-color: #f1f1f1; padding: 2px 5px; border-radius: 3px; }
+        ol { padding-left: 20px; }
+        li { margin-bottom: 10px; }
+        .tabs { display: flex; margin-bottom: 20px; }
+        .tab { padding: 10px 15px; cursor: pointer; background-color: #f8f9fa; border-radius: 4px 4px 0 0; margin-right: 5px; }
+        .tab.active { background-color: #0095f6; color: white; }
+        .tab-content { display: none; }
+        .tab-content.active { display: block; }
     </style>
 </head>
 <body>
     <div class="container">
+        <h1>Import Instagram Session</h1>
+        <div class="tabs">
+            <div class="tab active" onclick="switchTab('tab1', this)">Cookie Format</div>
+            <div class="tab" onclick="switchTab('tab2', this)">JSON Format</div>
+        </div>
+        <div id="tab1" class="tab-content active">
+            <div class="instructions">
+                <h3>How to get your Instagram cookies:</h3>
+                <ol>
+                    <li>Log in to Instagram in your browser</li>
+                    <li>Open browser DevTools (F12 or right-click and select "Inspect")</li>
+                    <li>Go to the "Application" or "Storage" tab</li>
+                    <li>Under "Cookies", find "instagram.com"</li>
+                    <li>Find the <span class="code">sessionid</span> cookie and copy its value</li>
+                    <li>Also copy the <span class="code">ds_user_id</span> and <span class="code">csrftoken</span> cookies if available</li>
+                    <li>Paste the cookies in the format: <span class="code">name=value; name2=value2;</span></li>
+                </ol>
             </div>
+            <form method="post" action="/import-cookies">
+                <div class="form-group">
+                    <label for="cookies">Paste your Instagram cookies here:</label>
+                    <textarea id="cookies" name="cookies" placeholder="sessionid=YOUR_SESSION_ID; ds_user_id=YOUR_USER_ID; csrftoken=YOUR_CSRF_TOKEN;" required></textarea>
+                </div>
+                <div class="form-group">
+                    <label for="username">Your Instagram username:</label>
+                    <input type="text" id="username" name="username" style="width: 100%; padding: 10px; border: 1px solid #dbdbdb; border-radius: 3px;" required>
+                </div>
+                <button type="submit" class="btn btn-block">Import Session</button>
+            </form>
+        </div>
+        <div id="tab2" class="tab-content">
+            <div class="instructions">
+                <h3>How to get your cookies as JSON:</h3>
+                <ol>
+                    <li>Install a browser extension like "EditThisCookie" or "Cookie-Editor"</li>
+                    <li>Log in to Instagram in your browser</li>
+                    <li>Click on the extension icon</li>
+                    <li>Choose "Export" or similar option to copy all cookies</li>
+                    <li>Paste the JSON data below</li>
+                </ol>
             </div>
+            <form method="post" action="/import-cookies-json">
+                <div class="form-group">
+                    <label for="cookies_json">Paste your Instagram cookies JSON here:</label>
+                    <textarea id="cookies_json" name="cookies_json" placeholder='[{"name":"sessionid","value":"YOUR_SESSION_ID","domain":".instagram.com"}]' required></textarea>
+                </div>
+                <div class="form-group">
+                    <label for="username_json">Your Instagram username:</label>
+                    <input type="text" id="username_json" name="username" style="width: 100%; padding: 10px; border: 1px solid #dbdbdb; border-radius: 3px;" required>
+                </div>
+                <button type="submit" class="btn btn-block">Import Session</button>
+            </form>
+        </div>
+        %s
     </div>
+    <script>
+        function switchTab(tabId, tabElement) {
+            // Hide all tab contents
+            document.querySelectorAll('.tab-content').forEach(content => {
+                content.classList.remove('active');
+            });
+            // Deactivate all tabs
+            document.querySelectorAll('.tab').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            // Activate clicked tab and its content
+            document.getElementById(tabId).classList.add('active');
+            tabElement.classList.add('active');
+        }
+    </script>
 </body>
 </html>
 """
+# Status page HTML
+STATUS_HTML = """
 <!DOCTYPE html>
 <html>
 <head>
+    <title>API Status</title>
     <style>
+        body { font-family: Arial; max-width: 600px; margin: 0 auto; padding: 20px; }
+        .container { background-color: #fff; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); padding: 25px; }
+        h1 { color: #262626; text-align: center; }
+        .status { display: inline-block; padding: 5px 10px; border-radius: 4px; margin-left: 10px; font-weight: bold; }
+        .connected { background-color: #e8f5e9; color: #388e3c; }
+        .disconnected { background-color: #ffebee; color: #d32f2f; }
+        .info { background-color: #f5f5f5; border-radius: 4px; padding: 15px; margin: 15px 0; }
+        .btn { background-color: #0095f6; border: none; color: white; padding: 10px 15px; border-radius: 4px; text-decoration: none; display: inline-block; margin-right: 10px; }
+        .btn-danger { background-color: #f44336; }
+        table { width: 100%%; border-collapse: collapse; margin-top: 15px; }
+        th, td { text-align: left; padding: 8px; border-bottom: 1px solid #ddd; }
     </style>
 </head>
 <body>
         <h1>Instagram API Status</h1>
         <h2>Connection Status
+            %s
         </h2>
+        <div class="info">
+            %s
         </div>
+        <a href="/import" class="btn">%s</a>
+        %s
         <h2>API Endpoints</h2>
         <table>
+            <tr><th>Endpoint</th><th>Description</th></tr>
+            <tr><td><code>/stories/{username}</code></td><td>Get stories for a user</td></tr>
+            <tr><td><code>/download/{url}</code></td><td>Download media from a URL</td></tr>
+            <tr><td><code>/status</code></td><td>View API status</td></tr>
         </table>
+        <h2>Cache Info</h2>
+        <div class="info">
+            <p>Cached users: %d</p>
+            <p>Total stories cached: %d</p>
         </div>
     </div>
 </body>
 </html>
 """
+# Functions for cache and Instagram session
 def get_cache_key(username):
     return username.lower()
 def get_cached_stories(username):
     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:
             STORY_CACHE.pop(key, None)
             CACHE_EXPIRY.pop(key, None)
     return None
 def save_to_cache(username, data, minutes=30):
     key = get_cache_key(username)
     STORY_CACHE[key] = data
     CACHE_EXPIRY[key] = datetime.now() + timedelta(minutes=minutes)
     try:
         cache_file = os.path.join(CACHE_DIR, f"{key}.json")
         with open(cache_file, 'w') as f:
         logger.warning(f"Failed to save cache: {str(e)}")
 def should_rate_limit_request(username):
     key = username.lower()
     now = datetime.now()
     if key in LAST_REQUEST:
         seconds_since = (now - LAST_REQUEST[key]).total_seconds()
+        if seconds_since < 60:
             logger.warning(f"Rate limiting {username}: {seconds_since:.1f}s since last request")
             return True
     return False
 def get_instagram_session():
     global IG_SESSION, IG_SESSION_EXPIRY
     if IG_SESSION is None or IG_SESSION_EXPIRY is None or datetime.now() > IG_SESSION_EXPIRY:
         if os.path.exists(COOKIES_FILE):
             try:
                 with open(COOKIES_FILE, 'r') as f:
                 if 'expires' in data and datetime.fromisoformat(data['expires']) > datetime.now():
                     IG_SESSION = requests.Session()
                     for cookie in data['cookies']:
                         IG_SESSION.cookies.set(
                             cookie['name'],
                             domain=cookie.get('domain', '.instagram.com')
                         )
                     IG_SESSION_EXPIRY = datetime.fromisoformat(data['expires'])
                     global IG_SESSION_USERNAME
                     IG_SESSION_USERNAME = data.get('username', 'unknown')
                     logger.info(f"Loaded Instagram session for {IG_SESSION_USERNAME}")
                     return IG_SESSION
                 else:
+                    logger.warning("Saved session expired, needs new import")
             except Exception as e:
                 logger.error(f"Failed to load cookies: {str(e)}")
     if IG_SESSION is not None and IG_SESSION_EXPIRY is not None and datetime.now() < IG_SESSION_EXPIRY:
         return IG_SESSION
     return None
+def save_instagram_session(cookies, username, days=30):
+    """Save imported cookie data"""
     global IG_SESSION, IG_SESSION_EXPIRY, IG_SESSION_USERNAME
+    IG_SESSION = requests.Session()
     IG_SESSION_EXPIRY = datetime.now() + timedelta(days=days)
     IG_SESSION_USERNAME = username
+    for cookie in cookies:
+        IG_SESSION.cookies.set(
+            cookie['name'],
+            cookie['value'],
+            domain=cookie.get('domain', '.instagram.com')
+        )
     try:
         with open(COOKIES_FILE, 'w') as f:
             json.dump({
                 'cookies': cookies,
         return False
 def clear_instagram_session():
     global IG_SESSION, IG_SESSION_EXPIRY, IG_SESSION_USERNAME
     IG_SESSION = None
         except Exception as e:
             logger.error(f"Failed to remove cookies file: {str(e)}")
+def parse_cookie_string(cookie_str):
+    """Parse cookie string into cookie objects"""
+    cookies = []
+    for cookie_part in cookie_str.split(';'):
+        cookie_part = cookie_part.strip()
+        if not cookie_part:
+            continue
+        if '=' in cookie_part:
+            name, value = cookie_part.split('=', 1)
+            cookies.append({
+                'name': name.strip(),
+                'value': value.strip(),
+                'domain': '.instagram.com'
+            })
+    return cookies
+def validate_imported_session(session):
+    """Check if the imported session seems valid"""
+    # Check for essential cookies
+    has_sessionid = any(c['name'] == 'sessionid' for c in session.cookies._cookies.get('.instagram.com', {}).get('/', {}).values())
+    if not has_sessionid:
+        return False
+    # Try to make a basic request
+    try:
+        response = session.get('https://www.instagram.com/accounts/edit/', allow_redirects=False)
+        # If we get redirected to login page, session is invalid
+        if response.status_code == 302 and 'login' in response.headers.get('Location', ''):
+            return False
+        return response.status_code == 200
+    except:
+        return False
 def get_instagram_stories(username):
     session = get_instagram_session()
     if not session:
         logger.warning("No valid Instagram session")
         session.headers.update({
             'User-Agent': random.choice(USER_AGENTS),
+            'X-IG-App-ID': '936619743392459',
+            'X-IG-WWW-Claim': 'hmac.AR1k18eNmvbsN7COEa9jpSQ9-NKGlK_TVqhgqxaGgxdCsIfR',
             'Referer': f'https://www.instagram.com/{username}/',
         })
         profile_response = session.get(profile_url)
         if profile_response.status_code != 200:
             logger.warning(f"Failed to get user profile: {profile_response.status_code}")
+            try:
+                resp_data = profile_response.json()
+                if 'message' in resp_data:
+                    return {"error": "api_error", "message": resp_data['message']}
+            except:
+                pass
+            return {"error": "profile_error", "status": profile_response.status_code}
         profile_data = profile_response.json()
         if 'data' not in profile_data or 'user' not in profile_data['data']:
+            return {"error": "not_found", "message": "User profile not found"}
         user_id = profile_data['data']['user']['id']
         time.sleep(random.uniform(1, 2))
+        # Get the stories
         stories_url = f"https://www.instagram.com/api/v1/feed/user/{user_id}/story/"
         stories_response = session.get(stories_url)
         if stories_response.status_code != 200:
+            return {"error": "stories_error", "status": stories_response.status_code}
         stories_data = stories_response.json()
         if 'reel' not in stories_data or not stories_data['reel'].get('items'):
+            return {"error": "no_stories", "message": "No stories found"}
         stories = []
         for item in stories_data['reel']['items']:
             story = {
             if story["type"] == "video" and 'video_versions' in item and item['video_versions']:
                 story["url"] = item['video_versions'][0]['url']
                 if 'view_count' in item:
                     story["views"] = item['view_count']
             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
             stories.append(story)
         if not stories:
+            return {"error": "no_valid_stories", "message": "No valid stories found"}
         result = {
             "data": stories,
         logger.error(f"Error getting stories: {str(e)}")
         return {"error": "exception", "message": str(e)}
+# Web routes
 @app.get("/", response_class=HTMLResponse)
+async def root():
     return RedirectResponse(url="/status")
+@app.get("/import", response_class=HTMLResponse)
+async def import_page(message: str = None, success: bool = False):
+    status_html = ""
+    if message:
+        status_class = "success" if success else "error"
+        status_html = f'<div class="status {status_class}">{message}</div>'
+    return HTMLResponse(COOKIE_IMPORT_HTML % status_html)
+@app.post("/import-cookies")
+async def import_cookies(cookies: str = Form(...), username: str = Form(...)):
+    logger.info(f"Importing cookies for {username}")
+    try:
+        cookie_objects = parse_cookie_string(cookies)
+        if not cookie_objects:
+            logger.warning("No valid cookies found in input")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">No valid cookies found in input</div>')
+        # Check for essential cookies
+        has_sessionid = any(c['name'] == 'sessionid' for c in cookie_objects)
+        if not has_sessionid:
+            logger.warning("Missing essential sessionid cookie")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Missing essential sessionid cookie</div>')
+        # Save session
+        if save_instagram_session(cookie_objects, username):
+            # Verify session
+            session = get_instagram_session()
+            if session:
+                # Try to make a basic request to test session
+                try:
+                    response = session.get('https://www.instagram.com/accounts/edit/', allow_redirects=False)
+                    if response.status_code == 302 and 'login' in response.headers.get('Location', ''):
+                        logger.warning("Session seems invalid - redirected to login")
+                        clear_instagram_session()
+                        return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Session validation failed - redirected to login</div>')
+                    logger.info("Session validated successfully")
+                    return RedirectResponse(url="/status", status_code=303)
+                except Exception as e:
+                    logger.error(f"Session validation error: {str(e)}")
+                    return HTMLResponse(COOKIE_IMPORT_HTML % f'<div class="status error">Session validation error: {str(e)}</div>')
+            else:
+                logger.error("Failed to get session after saving")
+                return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Failed to create session</div>')
+        else:
+            logger.error("Failed to save session")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Failed to save session</div>')
+    except Exception as e:
+        logger.error(f"Import error: {str(e)}")
+        return HTMLResponse(COOKIE_IMPORT_HTML % f'<div class="status error">Import error: {str(e)}</div>')
+@app.post("/import-cookies-json")
+async def import_cookies_json(cookies_json: str = Form(...), username: str = Form(...)):
+    logger.info(f"Importing JSON cookies for {username}")
+    try:
+        cookie_objects = json.loads(cookies_json)
+        if not isinstance(cookie_objects, list):
+            logger.warning("Invalid JSON format - expected array")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Invalid JSON format - expected array of cookie objects</div>')
+        # Check for essential cookies
+        has_sessionid = any(c.get('name') == 'sessionid' for c in cookie_objects)
+        if not has_sessionid:
+            logger.warning("Missing essential sessionid cookie")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Missing essential sessionid cookie</div>')
+        # Normalize cookie objects
+        for cookie in cookie_objects:
+            if 'domain' not in cookie:
+                cookie['domain'] = '.instagram.com'
+        # Save session
+        if save_instagram_session(cookie_objects, username):
+            # Verify session
+            session = get_instagram_session()
+            if session:
+                # Try to make a basic request to test session
+                try:
+                    response = session.get('https://www.instagram.com/accounts/edit/', allow_redirects=False)
+                    if response.status_code == 302 and 'login' in response.headers.get('Location', ''):
+                        logger.warning("Session seems invalid - redirected to login")
+                        clear_instagram_session()
+                        return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Session validation failed - redirected to login</div>')
+                    logger.info("Session validated successfully")
+                    return RedirectResponse(url="/status", status_code=303)
+                except Exception as e:
+                    logger.error(f"Session validation error: {str(e)}")
+                    return HTMLResponse(COOKIE_IMPORT_HTML % f'<div class="status error">Session validation error: {str(e)}</div>')
+            else:
+                logger.error("Failed to get session after saving")
+                return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Failed to create session</div>')
+        else:
+            logger.error("Failed to save session")
+            return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Failed to save session</div>')
+    except json.JSONDecodeError:
+        logger.error("Invalid JSON format")
+        return HTMLResponse(COOKIE_IMPORT_HTML % '<div class="status error">Invalid JSON format</div>')
+    except Exception as e:
+        logger.error(f"Import error: {str(e)}")
+        return HTMLResponse(COOKIE_IMPORT_HTML % f'<div class="status error">Import error: {str(e)}</div>')
 @app.get("/logout")
 async def logout():
     clear_instagram_session()
     return RedirectResponse(url="/status", status_code=303)
 @app.get("/status", response_class=HTMLResponse)
+async def status_page():
     session = get_instagram_session()
     session_valid = session is not None
+    # Status badge
+    status_badge = '<span class="status connected">Connected</span>' if session_valid else '<span class="status disconnected">Disconnected</span>'
+    # Status info
+    if session_valid:
+        status_info = f"<p>✅ You are currently logged in as <strong>{IG_SESSION_USERNAME}</strong></p>"
+        status_info += f"<p>Session will expire: {IG_SESSION_EXPIRY.strftime('%Y-%m-%d %H:%M:%S')}</p>"
+    else:
+        status_info = "<p>❌ No active Instagram session</p><p>Please import your cookies to use the API</p>"
+    # Button text
+    import_text = "Re-Import Cookies" if session_valid else "Import Cookies"
+    # Logout button
+    logout_button = '<a href="/logout" class="btn btn-danger">Logout</a>' if session_valid else ''
+    # Cache info
+    cache_count = len(STORY_CACHE)
+    story_count = sum(len(data.get("data", [])) for data in STORY_CACHE.values())
+    return HTMLResponse(STATUS_HTML % (status_badge, status_info, import_text, logout_button, cache_count, story_count))
+# API routes
 @app.get("/stories/{username}")
+async def get_stories(username: str, cached: bool = False):
     logger.info(f"Request for @{username} stories")
     if cached:
         cached_result = get_cached_stories(username)
         if cached_result:
             return {**cached_result, "from_cache": True}
     try:
         if should_rate_limit_request(username):
             cached_result = get_cached_stories(username)
             if cached_result:
                     detail="Rate limit exceeded. Please try again later."
                 )
         result = get_instagram_stories(username)
         if not result:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="No valid Instagram session. Please import your cookies first."
             )
         if "error" in result:
+            if result["error"] == "api_error":
                 cached_result = get_cached_stories(username)
                 if cached_result:
+                    return {**cached_result, "from_cache": True, "error_occurred": True}
                 raise HTTPException(
                     status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                    detail=result.get("message", "Instagram API error")
                 )
+            elif result["error"] in ["profile_error", "not_found"]:
                 raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Profile not found"
                 )
+            elif result["error"] in ["no_stories", "no_valid_stories"]:
                 raise HTTPException(
                     status_code=status.HTTP_404_NOT_FOUND,
+                    detail="No stories found for this user"
                 )
             else:
                     detail=result.get("message", "Failed to get stories")
                 )
         save_to_cache(username, result)
         return result
     except HTTPException:
         raise
     except Exception as e:
         logger.error(f"Error: {str(e)}")
         cached_result = get_cached_stories(username)
         if cached_result:
             return {**cached_result, "from_cache": True, "error_occurred": True}
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
         )
 @app.get("/download/{url:path}")
 async def download_media(url: str):
     logger.info(f"Download request for media")
     try:
         if not url.startswith(("https://", "http://")):
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail="Invalid URL format"
             )
         session = get_instagram_session() or requests.Session()
         headers = {
             "User-Agent": random.choice(USER_AGENTS),
             "Referer": "https://www.instagram.com/",
         }
         response = session.get(url, headers=headers, stream=True, timeout=15)
         response.raise_for_status()
         if "Content-Type" in response.headers:
             content_type = response.headers["Content-Type"]
         elif url.endswith((".jpg", ".jpeg")):
         logger.info(f"Media downloaded: {content_type}")
         return StreamingResponse(
             response.iter_content(chunk_size=8192),
             media_type=content_type,
                         cache_data = json.load(f)
                     if "data" in cache_data and "expires" in cache_data:
                         expires = datetime.fromisoformat(cache_data["expires"])
                         if expires > datetime.now():
                             key = filename.replace('.json', '')