Update app.py

app.py

@@ -1,66 +1,149 @@
-import logging
-from dotenv import load_dotenv
-import os
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, status
 from fastapi.responses import StreamingResponse
 import instaloader
 import requests
+import os
+import time
+from functools import wraps
 
-# Load environment variables
-load_dotenv()
+app = FastAPI(title="Instagram Stories API", docs_url=None, redoc_url=None)
 
-# Get credentials from environment variables
+# Load Instagram credentials from environment variables
 INSTAGRAM_USERNAME = os.getenv('INSTAGRAM_USERNAME')
 INSTAGRAM_PASSWORD = os.getenv('INSTAGRAM_PASSWORD')
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
+# Configure Instaloader with session persistence
+def get_instaloader():
+    L = instaloader.Instaloader()
+    
+    # Try to load existing session
+    try:
+        L.load_session_from_file(INSTAGRAM_USERNAME)
+    except FileNotFoundError:
+        # If session doesn't exist, perform login
+        try:
+            L.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
+            L.save_session_to_file()
+        except instaloader.exceptions.BadCredentialsException:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid Instagram credentials"
+            )
+        except instaloader.exceptions.TwoFactorAuthRequiredException:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Two-factor authentication required"
+            )
+    
+    # Set request delay to avoid rate limits
+    L.request_timeout = 300
+    L.sleep = True
+    L.delay_seconds = 5  # Minimum 5 seconds between requests
+    
+    return L
 
-app = FastAPI(title="Instagram Stories API", docs_url=None, redoc_url=None)
+def handle_instagram_errors(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except instaloader.exceptions.QueryReturnedBadRequestException:
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail="Instagram rate limit exceeded - try again later"
+            )
+        except instaloader.exceptions.ConnectionException:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Instagram connection failed - try again later"
+            )
+        except instaloader.exceptions.PrivateProfileNotFollowedException:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Cannot access private profile"
+            )
+    return wrapper
 
-@app.get("/stories/{username}", summary="Get available stories")
+@app.get("/stories/{username}")
+@handle_instagram_errors
 async def get_stories(username: str):
-    """Retrieve metadata for public Instagram stories"""
-    L = instaloader.Instaloader()
+    """Retrieve metadata for Instagram stories (public or private if followed)"""
+    L = get_instaloader()
+    
     try:
         profile = instaloader.Profile.from_username(L.context, username)
     except instaloader.exceptions.ProfileNotExistsException:
-        raise HTTPException(404, "Profile not found")
-    
-    stories = [{
-        "id": str(item.mediaid),
-        "url": item.url,
-        "type": "video" if item.is_video else "image",
-        "timestamp": item.date_utc.isoformat(),
-        "views": item.view_count
-    } for story in profile.get_stories() for item in story.get_items()]
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Profile not found")
     
-    return {"data": stories} if stories else HTTPException(404, "No stories found")
+    # Check if we can access stories
+    if not profile.has_public_story and not profile.is_followed_by_viewer:
+        raise HTTPException(
+            status.HTTP_403_FORBIDDEN,
+            "No accessible stories for this profile"
+        )
+
+    stories = []
+    try:
+        for story in L.get_stories(userids=[profile.userid]):
+            for item in story.get_items():
+                stories.append({
+                    "id": str(item.mediaid),
+                    "url": item.url,
+                    "type": "video" if item.is_video else "image",
+                    "timestamp": item.date_utc.isoformat(),
+                    "views": item.view_count if item.is_video else None,
+                })
+    except instaloader.exceptions.QueryReturnedNotFoundException:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            "Stories not found or expired"
+        )
+
+    if not stories:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            "No active stories available"
+        )
 
-@app.get("/download/{media_id}", summary="Download story content")
+    return {"data": stories}
+
+@app.get("/download/{media_id}")
+@handle_instagram_errors
 async def download_story(media_id: str, username: str):
     """Download specific story media by ID"""
-    L = instaloader.Instaloader()
+    L = get_instaloader()
+    
     try:
         profile = instaloader.Profile.from_username(L.context, username)
     except instaloader.exceptions.ProfileNotExistsException:
-        raise HTTPException(404, "Profile not found")
-
-    # Find the story item
-    story_item = next((item for story in profile.get_stories() 
-                      for item in story.get_items() 
-                      if str(item.mediaid) == media_id), None)
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Profile not found")
 
+    # Find the story item with retry logic
+    story_item = None
+    for _ in range(3):  # Retry up to 3 times
+        try:
+            story_item = next(
+                (item for story in L.get_stories(userids=[profile.userid])
+                for item in story.get_items()
+                if str(item.mediaid) == media_id
+            ), None)
+            if story_item:
+                break
+        except instaloader.exceptions.QueryReturnedBadRequestException:
+            time.sleep(10)  # Wait 10 seconds before retrying
+    
     if not story_item:
-        raise HTTPException(404, "Story not found")
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Story not found")
 
     try:
-        response = requests.get(story_item.url, stream=True)
+        # Use Instaloader's context to maintain session cookies
+        response = L.context.get(story_item.url, stream=True)
         response.raise_for_status()
     except requests.exceptions.RequestException:
-        raise HTTPException(500, "Failed to fetch media")
+        raise HTTPException(
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+            "Failed to fetch media content"
+        )
 
     return StreamingResponse(
         response.iter_content(chunk_size=8192),