Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from typing import Optional, List, Dict
@@ -25,7 +25,7 @@ app.add_middleware(
 )
 
 # ---------------------------
-# 📦 Persistent storage setup
+#  Persistent storage setup
 # ---------------------------
 PERSISTENT_ROOT = os.environ.get("PERSISTENT_DIR", "/data")
 CHAT_DIR = os.path.join(PERSISTENT_ROOT, "chat")
@@ -37,21 +37,32 @@ USERS_DIR = os.path.join(PERSISTENT_ROOT, "users")
 os.makedirs(USERS_DIR, exist_ok=True)
 USERS_FILE = os.path.join(USERS_DIR, "users.jsonl")
 SESSIONS_FILE = os.path.join(USERS_DIR, "sessions.json")
+
+# New storage files
+ROOMS_FILE = os.path.join(USERS_DIR, "rooms.json")
+VOTES_FILE = os.path.join(USERS_DIR, "votes.json")
+BADGES_FILE = os.path.join(USERS_DIR, "badges.json")
+
 ADMIN_KEY = os.environ.get("ADMIN_KEY", "")  # set in HF Space secrets
 
 # Async file locks
 app.state.chat_locks = {}
 app.state.users_lock = asyncio.Lock()
 app.state.sessions_lock = asyncio.Lock()
-app.state.sessions: Dict[str, str] = {}
+app.state.rooms_lock = asyncio.Lock()
+app.state.votes_lock = asyncio.Lock()
+app.state.badges_lock = asyncio.Lock()
 
+app.state.sessions: Dict[str, str] = {}
+app.state.rooms: List[Dict] = []
+app.state.votes: Dict[str, Dict] = {}  # post_id -> {upvotes: int, downvotes: int, voters: {user_handle: "up"|"down"}}
+app.state.badges: Dict[str, str] = {}  # user_handle -> badge_type
 
 def _chat_file_for(video_id: str) -> str:
     # Stable filename to avoid path traversal
     h = hashlib.sha256(video_id.encode("utf-8")).hexdigest()[:32]
     return os.path.join(CHAT_DIR, f"{h}.jsonl")
 
-
 def _lock_for(path: str) -> asyncio.Lock:
     lock = app.state.chat_locks.get(path)
     if lock is None:
@@ -59,45 +70,35 @@ def _lock_for(path: str) -> asyncio.Lock:
         app.state.chat_locks[path] = lock
     return lock
 
-
 def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
-
 def _valid_author(s: Optional[str]) -> str:
     s = (s or "anon").strip()
     s = re.sub(r"\s+", " ", s)
     return s[:32] or "anon"
 
-
 def _valid_text(s: str) -> str:
     s = (s or "").rstrip("\n")
     return s[:2000]
 
-
 async def _append_jsonl(path: str, record: dict) -> None:
     line = json.dumps(record, ensure_ascii=False) + "\n"
-
     def _write():
         with open(path, "a", encoding="utf-8") as f:
             f.write(line)
-
     await asyncio.to_thread(_write)
 
-
 async def _read_jsonl(path: str) -> List[dict]:
     if not os.path.exists(path):
         return []
-
     def _read():
         with open(path, "r", encoding="utf-8") as f:
             return [json.loads(x) for x in f if x.strip()]
-
     return await asyncio.to_thread(_read)
 
-
 # ---------------------------
-# 👤 Users & Auth helpers
+#  Users & Auth helpers
 # ---------------------------
 
 def _safe_handle(s: str) -> str:
@@ -105,44 +106,34 @@ def _safe_handle(s: str) -> str:
     s = re.sub(r"[^a-zA-Z0-9_.~-]", "_", s)
     return s[:24]
 
-
 def _hash_pin(pin: str) -> str:
     return hashlib.sha256(("tlks|" + pin).encode("utf-8")).hexdigest()
 
-
 def _rand_token() -> str:
     return hashlib.sha256(os.urandom(32)).hexdigest()
 
-
 def _gen_temp_pin(digits: int = 6) -> str:
     # numeric temp PIN (easier to convey to students)
     lower = 10 ** (digits - 1)
     return str(random.randint(lower, 10 ** digits - 1))
 
-
 async def _append_user(record: dict) -> None:
     line = json.dumps(record, ensure_ascii=False) + "\n"
-
     def _write():
         with open(USERS_FILE, "a", encoding="utf-8") as f:
             f.write(line)
-
     async with app.state.users_lock:
         await asyncio.to_thread(_write)
 
-
 async def _read_users() -> List[dict]:
     if not os.path.exists(USERS_FILE):
         return []
-
     def _read():
         with open(USERS_FILE, "r", encoding="utf-8") as f:
             return [json.loads(x) for x in f if x.strip()]
-
     async with app.state.users_lock:
         return await asyncio.to_thread(_read)
 
-
 async def _load_sessions():
     if os.path.exists(SESSIONS_FILE):
         def _read():
@@ -152,35 +143,94 @@ async def _load_sessions():
     else:
         app.state.sessions = {}
 
-
 async def _save_sessions():
     def _write(data):
         with open(SESSIONS_FILE, "w", encoding="utf-8") as f:
             json.dump(data, f)
-
     async with app.state.sessions_lock:
         await asyncio.to_thread(_write, app.state.sessions)
 
+# New storage functions
+async def _load_rooms():
+    if os.path.exists(ROOMS_FILE):
+        def _read():
+            with open(ROOMS_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        app.state.rooms = await asyncio.to_thread(_read)
+    else:
+        # Default rooms
+        app.state.rooms = [
+            {"id": "main", "name": "General", "private": False},
+            {"id": "math101", "name": "Math 101", "private": True, "invite": "MATH-101-2024"},
+            {"id": "eng101", "name": "English 101", "private": True, "invite": "ENG-101-2024"},
+            {"id": "grade6", "name": "Grade 6", "private": True, "invite": "GRADE6-OK"},
+            {"id": "grade7", "name": "Grade 7", "private": True, "invite": "GRADE7-OK"}
+        ]
+        await _save_rooms()
+
+async def _save_rooms():
+    def _write(data):
+        with open(ROOMS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f)
+    async with app.state.rooms_lock:
+        await asyncio.to_thread(_write, app.state.rooms)
+
+async def _load_votes():
+    if os.path.exists(VOTES_FILE):
+        def _read():
+            with open(VOTES_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        app.state.votes = await asyncio.to_thread(_read)
+    else:
+        app.state.votes = {}
+
+async def _save_votes():
+    def _write(data):
+        with open(VOTES_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f)
+    async with app.state.votes_lock:
+        await asyncio.to_thread(_write, app.state.votes)
+
+async def _load_badges():
+    if os.path.exists(BADGES_FILE):
+        def _read():
+            with open(BADGES_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        app.state.badges = await asyncio.to_thread(_read)
+    else:
+        app.state.badges = {}
+
+async def _save_badges():
+    def _write(data):
+        with open(BADGES_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f)
+    async with app.state.badges_lock:
+        await asyncio.to_thread(_write, app.state.badges)
 
 @app.on_event("startup")
-async def _startup_load_sessions():
+async def _startup_load_data():
     await _load_sessions()
-
+    await _load_rooms()
+    await _load_votes()
+    await _load_badges()
 
 def _require_admin(request: Request):
     provided = request.headers.get("x-admin-key", "")
     if not ADMIN_KEY or provided != ADMIN_KEY:
         raise fastapi.HTTPException(status_code=401, detail="Admin key required")
 
+def _is_verified_staff(handle: str) -> bool:
+    """Check if user is verified staff (can moderate)"""
+    VERIFIED_STAFF = {"teacher1", "staff", "alex"}  # Configure as needed
+    return handle in VERIFIED_STAFF
 
 # ---------------------------
-# 💬 Chat API (public read, authed write)
+#  Chat API (public read, authed write)
 # ---------------------------
 class NewMessage(BaseModel):
     author: Optional[str] = Field(default="anon", max_length=64)  # ignored on server write
     text: str = Field(..., min_length=1, max_length=5000)
 
-
 @app.get("/chat/{video_id}")
 async def get_messages(video_id: str, limit: int = 50, since: Optional[str] = None):
     """
@@ -206,11 +256,56 @@ async def get_messages(video_id: str, limit: int = 50, since: Optional[str] = No
     if len(items) > limit:
         items = items[-limit:]
 
+    # Add vote counts and badges to messages
+    for item in items:
+        post_id = item.get("id")
+        if post_id and post_id in app.state.votes:
+            vote_data = app.state.votes[post_id]
+            item["upvotes"] = vote_data.get("upvotes", 0)
+            item["downvotes"] = vote_data.get("downvotes", 0)
+        else:
+            item["upvotes"] = 0
+            item["downvotes"] = 0
+        
+        # Add badge info
+        handle = item.get("handle")
+        if handle and handle in app.state.badges:
+            item["badge"] = app.state.badges[handle]
+
     return {"video_id": video_id, "count": len(items), "messages": items}
 
+@app.delete("/chat/{video_id}/{message_id}")
+async def delete_message(video_id: str, message_id: str, request: Request):
+    """
+    Delete a message (staff only)
+    """
+    user = await _require_user(request)
+    if not _is_verified_staff(user["handle"]):
+        raise HTTPException(status_code=403, detail="Staff access required")
+    
+    path = _chat_file_for(video_id)
+    lock = _lock_for(path)
+    
+    async with lock:
+        items = await _read_jsonl(path)
+        original_count = len(items)
+        items = [m for m in items if m.get("id") != message_id]
+        
+        if len(items) == original_count:
+            raise HTTPException(status_code=404, detail="Message not found")
+        
+        # Rewrite file without the deleted message
+        def _write_all():
+            with open(path, "w", encoding="utf-8") as f:
+                for item in items:
+                    f.write(json.dumps(item, ensure_ascii=False) + "\n")
+        await asyncio.to_thread(_write_all)
+    
+    logging.info(f"Message {message_id} deleted by {user['handle']}")
+    return {"ok": True}
 
 # ---------------------------
-# 👤 Users & Auth API
+#  Users & Auth API
 # ---------------------------
 class NewUser(BaseModel):
     email: str
@@ -222,7 +317,6 @@ class NewUser(BaseModel):
     description: Optional[str] = ""
     pin: str = Field(..., min_length=3, max_length=32)
 
-
 class UpdateUser(BaseModel):
     first_name: Optional[str] = None
     last_name: Optional[str] = None
@@ -232,12 +326,15 @@ class UpdateUser(BaseModel):
     pin: Optional[str] = None
     disabled: Optional[bool] = None
 
+class UpdateProfile(BaseModel):
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    profile_image: Optional[str] = None
 
 class LoginReq(BaseModel):
     handle: str
     pin: str
 
-
 @app.post("/admin/users")
 async def admin_create_user(user: NewUser, request: Request):
     _require_admin(request)
@@ -264,7 +361,6 @@ async def admin_create_user(user: NewUser, request: Request):
     pub = {k: v for k, v in rec.items() if k != "pin_hash"}
     return {"ok": True, "user": pub}
 
-
 @app.get("/admin/users")
 async def admin_list_users(request: Request, q: Optional[str] = None, limit: int = 200):
     _require_admin(request)
@@ -277,7 +373,6 @@ async def admin_list_users(request: Request, q: Optional[str] = None, limit: int
         u.pop("pin_hash", None)
     return {"count": len(users), "users": users}
 
-
 @app.get("/admin/users/{handle}")
 async def admin_get_user(handle: str, request: Request):
     """
@@ -293,7 +388,6 @@ async def admin_get_user(handle: str, request: Request):
     pub = {k: v for k, v in u.items() if k != "pin_hash"}
     return {"ok": True, "user": pub}
 
-
 @app.put("/admin/users/{handle}")
 async def admin_update_user(handle: str, patch: UpdateUser, request: Request):
     _require_admin(request)
@@ -331,6 +425,39 @@ async def admin_update_user(handle: str, patch: UpdateUser, request: Request):
         await asyncio.to_thread(_write_all)
     return {"ok": True}
 
+@app.put("/me/profile")
+async def update_my_profile(patch: UpdateProfile, request: Request):
+    """
+    Update current user's profile
+    """
+    user = await _require_user(request)
+    handle = user["handle"]
+    
+    users = await _read_users()
+    changed = False
+    for u in users:
+        if u.get("handle") == handle:
+            if patch.first_name is not None:
+                u["first_name"] = patch.first_name.strip()
+            if patch.last_name is not None:
+                u["last_name"] = patch.last_name.strip()
+            if patch.profile_image is not None:
+                u["profile_image"] = patch.profile_image.strip()
+            changed = True
+            break
+    
+    if not changed:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    # rewrite file
+    async with app.state.users_lock:
+        def _write_all():
+            with open(USERS_FILE, "w", encoding="utf-8") as f:
+                for rec in users:
+                    f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        await asyncio.to_thread(_write_all)
+    
+    return {"ok": True}
 
 @app.post("/admin/users/{handle}/reset_pin")
 async def admin_reset_pin(handle: str, body: dict = None, request: Request = None):
@@ -378,7 +505,6 @@ async def admin_reset_pin(handle: str, body: dict = None, request: Request = Non
     logging.info(f"Admin reset PIN for @{handle}")
     return {"ok": True, "new_pin": new_pin}
 
-
 @app.post("/auth/login")
 async def login(req: LoginReq):
     users = await _read_users()
@@ -395,7 +521,6 @@ async def login(req: LoginReq):
     # include must_change_pin to allow client to force password change
     return {"ok": True, "token": token, "must_change_pin": bool(u.get("must_change_pin", False))}
 
-
 async def _require_user(request: Request) -> dict:
     auth = request.headers.get("authorization", "")
     if not auth.lower().startswith("bearer "):
@@ -411,13 +536,232 @@ async def _require_user(request: Request) -> dict:
         raise fastapi.HTTPException(status_code=401, detail="User disabled")
     return user
 
-
 @app.get("/me")
 async def me(request: Request):
     user = await _require_user(request)
     pub = {k: v for k, v in user.items() if k not in ("pin_hash",)}
     return {"ok": True, "user": pub}
 
+# ---------------------------
+#  Rooms API
+# ---------------------------
+
+class NewRoom(BaseModel):
+    name: str = Field(..., min_length=1, max_length=64)
+    room_id: str = Field(..., min_length=1, max_length=32)
+    private: bool = False
+    invite_code: Optional[str] = None
+
+class RoomAccessRequest(BaseModel):
+    invite_code: str
+
+@app.get("/rooms")
+async def get_rooms():
+    """
+    Get all rooms (without invite codes for security)
+    """
+    rooms = []
+    for room in app.state.rooms:
+        room_data = {
+            "id": room["id"],
+            "name": room["name"],
+            "private": room.get("private", False)
+        }
+        rooms.append(room_data)
+    return {"rooms": rooms}
+
+@app.post("/rooms")
+async def create_room(room_data: NewRoom, request: Request):
+    """
+    Create a new room (staff only)
+    """
+    user = await _require_user(request)
+    if not _is_verified_staff(user["handle"]):
+        raise HTTPException(status_code=403, detail="Staff access required")
+    
+    # Validate room_id
+    room_id = re.sub(r"[^a-zA-Z0-9_.~-]", "_", room_data.room_id.strip())
+    if not room_id:
+        raise HTTPException(status_code=400, detail="Invalid room ID")
+    
+    # Check if room already exists
+    if any(r["id"] == room_id for r in app.state.rooms):
+        raise HTTPException(status_code=400, detail="Room ID already exists")
+    
+    # Validate invite code for private rooms
+    if room_data.private and not room_data.invite_code:
+        raise HTTPException(status_code=400, detail="Private rooms require an invite code")
+    
+    new_room = {
+        "id": room_id,
+        "name": room_data.name.strip(),
+        "private": room_data.private,
+        "created_by": user["handle"],
+        "created_at": _now_iso()
+    }
+    
+    if room_data.private and room_data.invite_code:
+        new_room["invite"] = room_data.invite_code.strip()
+    
+    app.state.rooms.append(new_room)
+    await _save_rooms()
+    
+    logging.info(f"Room {room_id} created by {user['handle']}")
+    
+    # Return room without invite code
+    public_room = {k: v for k, v in new_room.items() if k != "invite"}
+    return {"ok": True, "room": public_room}
+
+@app.post("/rooms/{room_id}/access")
+async def request_room_access(room_id: str, access_req: RoomAccessRequest, request: Request):
+    """
+    Request access to a private room with invite code
+    """
+    user = await _require_user(request)
+    
+    room = next((r for r in app.state.rooms if r["id"] == room_id), None)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+    
+    if not room.get("private"):
+        return {"ok": True, "access_granted": True}  # Public room
+    
+    if room.get("invite") == access_req.invite_code.strip():
+        return {"ok": True, "access_granted": True}
+    else:
+        return {"ok": False, "access_granted": False, "error": "Invalid invite code"}
+
+# ---------------------------
+#  Voting API
+# ---------------------------
+
+class VoteRequest(BaseModel):
+    vote_type: str  # "up" or "down"
+
+@app.post("/chat/{video_id}/{message_id}/vote")
+async def vote_message(video_id: str, message_id: str, vote_req: VoteRequest, request: Request):
+    """
+    Vote on a message
+    """
+    user = await _require_user(request)
+    handle = user["handle"]
+    
+    if vote_req.vote_type not in ["up", "down"]:
+        raise HTTPException(status_code=400, detail="Invalid vote type")
+    
+    # Initialize vote data if doesn't exist
+    if message_id not in app.state.votes:
+        app.state.votes[message_id] = {
+            "upvotes": 0,
+            "downvotes": 0,
+            "voters": {}
+        }
+    
+    vote_data = app.state.votes[message_id]
+    current_vote = vote_data["voters"].get(handle)
+    
+    # Remove previous vote
+    if current_vote == "up":
+        vote_data["upvotes"] = max(0, vote_data["upvotes"] - 1)
+    elif current_vote == "down":
+        vote_data["downvotes"] = max(0, vote_data["downvotes"] - 1)
+    
+    # Add new vote (or remove if same)
+    if current_vote == vote_req.vote_type:
+        # Toggle off - remove vote
+        del vote_data["voters"][handle]
+    else:
+        # Add new vote
+        vote_data["voters"][handle] = vote_req.vote_type
+        if vote_req.vote_type == "up":
+            vote_data["upvotes"] += 1
+        else:
+            vote_data["downvotes"] += 1
+    
+    await _save_votes()
+    
+    return {
+        "ok": True,
+        "upvotes": vote_data["upvotes"],
+        "downvotes": vote_data["downvotes"],
+        "user_vote": vote_data["voters"].get(handle)
+    }
+
+@app.get("/chat/{video_id}/{message_id}/votes")
+async def get_message_votes(video_id: str, message_id: str, request: Request):
+    """
+    Get vote counts for a message
+    """
+    user = await _require_user(request)
+    handle = user["handle"]
+    
+    if message_id not in app.state.votes:
+        return {
+            "upvotes": 0,
+            "downvotes": 0,
+            "user_vote": None
+        }
+    
+    vote_data = app.state.votes[message_id]
+    return {
+        "upvotes": vote_data["upvotes"],
+        "downvotes": vote_data["downvotes"],
+        "user_vote": vote_data["voters"].get(handle)
+    }
+
+# ---------------------------
+#  Badge API
+# ---------------------------
+
+class BadgeRequest(BaseModel):
+    badge_type: str  # "gold", "silver", "green", or "none" to remove
+
+@app.post("/users/{target_handle}/badge")
+async def assign_badge(target_handle: str, badge_req: BadgeRequest, request: Request):
+    """
+    Assign badge to user (staff only)
+    """
+    user = await _require_user(request)
+    if not _is_verified_staff(user["handle"]):
+        raise HTTPException(status_code=403, detail="Staff access required")
+    
+    target_handle = _safe_handle(target_handle)
+    
+    # Verify target user exists
+    users = await _read_users()
+    target_user = next((u for u in users if u.get("handle") == target_handle), None)
+    if not target_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    valid_badges = {"gold", "silver", "green", "none"}
+    if badge_req.badge_type not in valid_badges:
+        raise HTTPException(status_code=400, detail="Invalid badge type")
+    
+    if badge_req.badge_type == "none":
+        # Remove badge
+        if target_handle in app.state.badges:
+            del app.state.badges[target_handle]
+    else:
+        # Assign badge
+        app.state.badges[target_handle] = badge_req.badge_type
+    
+    await _save_badges()
+    
+    logging.info(f"Badge {badge_req.badge_type} assigned to {target_handle} by {user['handle']}")
+    return {"ok": True}
+
+@app.get("/users/{handle}/badge")
+async def get_user_badge(handle: str):
+    """
+    Get user's badge
+    """
+    handle = _safe_handle(handle)
+    badge = app.state.badges.get(handle)
+    return {"badge": badge}
+
+# ---------------------------
+#  Enhanced Chat API
+# ---------------------------
 
 @app.post("/chat/{video_id}")
 async def post_message(video_id: str, msg: NewMessage, request: Request):
@@ -461,24 +805,22 @@ async def post_message(video_id: str, msg: NewMessage, request: Request):
 
     return {"ok": True, "message": record}
 
-
-# (rest of your iCloud album endpoints unchanged)
+# ---------------------------
+#  iCloud album endpoints (unchanged)
+# ---------------------------
 BASE_62_MAP = {c: i for i, c in enumerate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")}
 
-
 async def get_client() -> httpx.AsyncClient:
     if not hasattr(app.state, "client"):
         app.state.client = httpx.AsyncClient(timeout=15.0)
     return app.state.client
 
-
 def base62_to_int(token: str) -> int:
     result = 0
     for ch in token:
         result = result * 62 + BASE_62_MAP[ch]
     return result
 
-
 async def get_base_url(token: str) -> str:
     first = token[0]
     if first == "A":
@@ -487,19 +829,12 @@ async def get_base_url(token: str) -> str:
         n = base62_to_int(token[1:3])
     return f"https://p{n:02d}-sharedstreams.icloud.com/{token}/sharedstreams/"
 
-
-
-
-# ... (keep your existing iCloud helper endpoints as-is) ...
-
-
 ICLOUD_HEADERS = {
     "Origin": "https://www.icloud.com",
     "Content-Type": "text/plain",
 }
 ICLOUD_PAYLOAD = '{"streamCtag":null}'
 
-
 async def get_redirected_base_url(base_url: str, token: str) -> str:
     client = await get_client()
     resp = await client.post(
@@ -521,31 +856,26 @@ async def get_redirected_base_url(base_url: str, token: str) -> str:
     else:
         resp.raise_for_status()
 
-
 async def post_json(path: str, base_url: str, payload: str) -> dict:
     client = await get_client()
     resp = await client.post(f"{base_url}{path}", headers=ICLOUD_HEADERS, data=payload)
     resp.raise_for_status()
     return resp.json()
 
-
 async def get_metadata(base_url: str) -> list:
     data = await post_json("webstream", base_url, ICLOUD_PAYLOAD)
     return data.get("photos", [])
 
-
 async def get_asset_urls(base_url: str, guids: list) -> dict:
     payload = json.dumps({"photoGuids": guids})
     data = await post_json("webasseturls", base_url, payload)
     return data.get("items", {})
 
-
 @app.get("/album/{token}")
 async def get_album(token: str):
     try:
         base_url = await get_base_url(token)
         base_url = await get_redirected_base_url(base_url, token)
-
         metadata = await get_metadata(base_url)
         guids = [photo["photoGuid"] for photo in metadata]
         asset_map = await get_asset_urls(base_url, guids)
@@ -589,7 +919,6 @@ async def get_album(token: str):
         logging.exception("Error in get_album")
         return {"error": str(e)}
 
-
 @app.get("/album/{token}/raw")
 async def get_album_raw(token: str):
     try:
@@ -601,4 +930,4 @@ async def get_album_raw(token: str):
         return {"metadata": metadata, "asset_urls": asset_map}
     except Exception as e:
         logging.exception("Error in get_album_raw")
-        return {"error": str(e)}
+        return {"error": str(e)}