Update app.py

app.py

@@ -1,3 +1,5 @@
+# storage manager
+
 import os
 import json
 import uuid
@@ -12,7 +14,7 @@ import uvicorn
 from fastapi import FastAPI, HTTPException, UploadFile, File, Form, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from aiocache import Cache
 
 # Google Cloud Imports
@@ -38,29 +40,35 @@ STORAGE_MAP = {
 # --- GLOBAL OBJECTS ---
 gcs_client = None
 bucket = None
-io_executor = ThreadPoolExecutor(max_workers=20) # GCS handles high concurrency well
+# GCS handles high concurrency well
+io_executor = ThreadPoolExecutor(max_workers=20)
 cache = Cache(Cache.MEMORY)
-INDEX_LOCK = asyncio.Lock() # Prevents race conditions during index writes
+INDEX_LOCK = asyncio.Lock()  # Prevents race conditions during index writes
 
 # --- HELPERS ---
 
+
 def get_gcs_client():
     """Initializes the GCS Client from environment variable string or file"""
     if CREDENTIALS_JSON:
         # Load credentials from the JSON string stored in secrets
         cred_info = json.loads(CREDENTIALS_JSON)
-        creds = service_account.Credentials.from_service_account_info(cred_info)
+        creds = service_account.Credentials.from_service_account_info(
+            cred_info)
         return storage.Client(credentials=creds)
     else:
         # Fallback to standard environment variable lookups (local dev)
         return storage.Client()
 
+
 async def run_io(func, *args, **kwargs):
     """Runs blocking GCS I/O in a thread pool"""
     loop = asyncio.get_running_loop()
     return await loop.run_in_executor(io_executor, lambda: func(*args, **kwargs))
 
 # --- LIFESPAN ---
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global gcs_client, bucket
@@ -79,14 +87,14 @@ app = FastAPI(lifespan=lifespan)
 # Replace ["*"] with your actual external site URL to prevent strangers from using your API
 ALLOWED_ORIGINS = [
     "http://localhost:3000",       # For your local testing
-    "https://test.1ink.us", # <--- REPLACE THIS with your actual site
-    "https://go.1ink.us", # <--- REPLACE THIS with your actual site
-    "https://noahcohn.com", # <--- REPLACE THIS with your actual site
+    "https://test.1ink.us",  # <--- REPLACE THIS with your actual site
+    "https://go.1ink.us",  # <--- REPLACE THIS with your actual site
+    "https://noahcohn.com",  # <--- REPLACE THIS with your actual site
 ]
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=ALLOWED_ORIGINS, # Uses the list above
+    allow_origins=ALLOWED_ORIGINS,  # Uses the list above
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -131,12 +139,16 @@ async def list_gcs_folder(folder: str = Query(..., description="Folder name, e.g
         raise HTTPException(status_code=500, detail=str(e))
 
 # --- MODELS ---
+
+
 class ItemPayload(BaseModel):
     name: str
     author: str
     description: Optional[str] = ""
     type: str = "song"
     data: dict
+    rating: Optional[int] = None
+
 
 class MetaData(BaseModel):
     id: str
@@ -146,15 +158,18 @@ class MetaData(BaseModel):
     type: str
     description: Optional[str] = ""
     filename: str
+    rating: Optional[int] = None
 
 # --- GCS I/O HELPERS ---
 
+
 def _read_json_sync(blob_path):
     blob = bucket.blob(blob_path)
     if blob.exists():
         return json.loads(blob.download_as_text())
     return []
 
+
 def _write_json_sync(blob_path, data):
     blob = bucket.blob(blob_path)
     # Upload as JSON string with correct content type
@@ -165,16 +180,20 @@ def _write_json_sync(blob_path, data):
 
 # --- ENDPOINTS ---
 
+
 @app.get("/")
 def home():
     return {"status": "online", "provider": "Google Cloud Storage"}
 
 # --- 1. LISTING (Cached) ---
+
+
 @app.get("/api/songs", response_model=List[MetaData])
 async def list_library(type: Optional[str] = Query(None)):
     cache_key = f"library:{type or 'all'}"
     cached = await cache.get(cache_key)
-    if cached: return cached
+    if cached:
+        return cached
 
     search_types = [type] if type else ["song", "pattern", "bank"]
     results = []
@@ -193,6 +212,8 @@ async def list_library(type: Optional[str] = Query(None)):
     return results
 
 # --- 2. UPLOAD JSON ---
+
+
 @app.post("/api/songs")
 async def upload_item(payload: ItemPayload):
     item_id = str(uuid.uuid4())
@@ -201,7 +222,7 @@ async def upload_item(payload: ItemPayload):
     config = STORAGE_MAP[item_type]
 
     filename = f"{item_id}.json"
-    full_path = f"{config['folder']}{filename}" # e.g., songs/uuid.json
+    full_path = f"{config['folder']}{filename}"  # e.g., songs/uuid.json
 
     meta = {
         "id": item_id,
@@ -210,7 +231,8 @@ async def upload_item(payload: ItemPayload):
         "date": date_str,
         "type": item_type,
         "description": payload.description,
-        "filename": filename
+        "filename": filename,
+        "rating": payload.rating
     }
 
     # Add meta to the actual data file too
@@ -236,6 +258,8 @@ async def upload_item(payload: ItemPayload):
             raise HTTPException(500, f"Upload failed: {str(e)}")
 
 # --- 2.5 UPDATE JSON (PUT) ---
+
+
 @app.put("/api/songs/{item_id}")
 async def update_item(item_id: str, payload: ItemPayload):
     # Verify type configuration
@@ -253,7 +277,8 @@ async def update_item(item_id: str, payload: ItemPayload):
     # We will fetch the original creation date if possible, or just use current if not found.
     # However, to avoid complexity, we'll just update the metadata entry in the index.
 
-    date_str = datetime.now().strftime("%Y-%m-%d") # Use current date as 'last updated' effectively?
+    # Use current date as 'last updated' effectively?
+    date_str = datetime.now().strftime("%Y-%m-%d")
     # Or should we try to preserve original date?
     # Let's try to preserve it by reading the index first.
 
@@ -261,10 +286,11 @@ async def update_item(item_id: str, payload: ItemPayload):
         "id": item_id,
         "name": payload.name,
         "author": payload.author,
-        "date": date_str, # Defaulting to now if not found
+        "date": date_str,  # Defaulting to now if not found
         "type": item_type,
         "description": payload.description,
-        "filename": filename
+        "filename": filename,
+        "rating": payload.rating
     }
 
     # Add meta to data
@@ -283,12 +309,14 @@ async def update_item(item_id: str, payload: ItemPayload):
             # 3. Update the Index
             def _update_index_logic():
                 current = _read_json_sync(config["index"])
-                if not isinstance(current, list): current = []
+                if not isinstance(current, list):
+                    current = []
 
                 # Find and remove existing entry for this ID
                 # Also, capture the original date if possible to preserve "Created Date" behavior
                 # But user might want "Updated Date". Let's stick to updating it to "now" so it bubbles to top.
-                existing_index = next((i for i, item in enumerate(current) if item.get("id") == item_id), -1)
+                existing_index = next((i for i, item in enumerate(
+                    current) if item.get("id") == item_id), -1)
 
                 if existing_index != -1:
                     # Preserve original creation date if desired, but user wants 'latest' usually.
@@ -308,7 +336,33 @@ async def update_item(item_id: str, payload: ItemPayload):
             raise HTTPException(500, f"Update failed: {str(e)}")
 
 
-# --- 3. FETCH JSON ITEM ---
+# --- 3. FETCH METADATA (without full data) ---
+
+@app.get("/api/songs/{item_id}/meta")
+async def get_item_metadata(item_id: str, type: Optional[str] = Query(None)):
+    """
+    Returns only the metadata for an item without the full data payload.
+    Much faster for listing/details views.
+    """
+    search_types = [type] if type else ["song", "pattern", "bank"]
+    
+    for t in search_types:
+        config = STORAGE_MAP.get(t)
+        if not config:
+            continue
+            
+        # Read from index (much faster than fetching full file)
+        index_data = await run_io(_read_json_sync, config["index"])
+        
+        if isinstance(index_data, list):
+            entry = next((item for item in index_data if item.get("id") == item_id), None)
+            if entry:
+                return entry
+    
+    raise HTTPException(404, "Item not found")
+
+
+# --- 3.5 FETCH JSON ITEM ---
 @app.get("/api/songs/{item_id}")
 async def get_item(item_id: str, type: Optional[str] = Query(None)):
     # Try to find the file
@@ -330,8 +384,14 @@ async def get_item(item_id: str, type: Optional[str] = Query(None)):
 
 # --- 4. STREAMING SAMPLES (Upload & Download) ---
 
+
 @app.post("/api/samples")
-async def upload_sample(file: UploadFile = File(...), author: str = Form(...), description: str = Form("")):
+async def upload_sample(
+    file: UploadFile = File(...), 
+    author: str = Form(...), 
+    description: str = Form(""),
+    rating: Optional[int] = Form(None)
+):
     sample_id = str(uuid.uuid4())
     ext = os.path.splitext(file.filename)[1]
     storage_filename = f"{sample_id}{ext}"
@@ -345,7 +405,8 @@ async def upload_sample(file: UploadFile = File(...), author: str = Form(...), d
         "date": datetime.now().strftime("%Y-%m-%d"),
         "type": "sample",
         "description": description,
-        "filename": storage_filename
+        "filename": storage_filename,
+        "rating": rating
     }
 
     async with INDEX_LOCK:
@@ -371,6 +432,7 @@ async def upload_sample(file: UploadFile = File(...), author: str = Form(...), d
         except Exception as e:
             raise HTTPException(500, str(e))
 
+
 @app.get("/api/samples/{sample_id}")
 async def get_sample(sample_id: str):
     config = STORAGE_MAP["sample"]
@@ -392,17 +454,91 @@ async def get_sample(sample_id: str):
     # GCS blob.open() returns a file-like object we can stream
     def iterfile():
         with blob.open("rb") as f:
-            while chunk := f.read(1024 * 1024): # 1MB chunks
+            while chunk := f.read(1024 * 1024):  # 1MB chunks
                 yield chunk
 
     return StreamingResponse(
         iterfile(),
         media_type="application/octet-stream",
-        headers={"Content-Disposition": f"attachment; filename={entry['name']}"}
+        headers={
+            "Content-Disposition": f"attachment; filename={entry['name']}"}
     )
 
+# --- 4.5 UPDATE SAMPLE METADATA ---
+
+
+class SampleMetaUpdatePayload(BaseModel):
+    """Payload for updating a sample's metadata."""
+    name: Optional[str] = None
+    description: Optional[str] = None
+    rating: Optional[int] = Field(
+        None, ge=1, le=10, description="A rating from 1 to 10.")
+
+
+@app.put("/api/samples/{sample_id}")
+async def update_sample_metadata(sample_id: str, payload: SampleMetaUpdatePayload):
+    """
+    Updates the metadata (name, description, rating) for a sample (e.g., a FLAC file).
+    This only modifies the JSON index, not the audio file itself.
+    """
+    config = STORAGE_MAP["sample"]
+    index_path = config["index"]
+
+    async with INDEX_LOCK:
+        try:
+            # 1. Read the index
+            index_data = await run_io(_read_json_sync, index_path)
+            if not isinstance(index_data, list):
+                raise HTTPException(
+                    status_code=500, detail="Sample index is corrupted.")
+
+            # 2. Find the item and its index
+            entry_index = next((i for i, item in enumerate(
+                index_data) if item.get("id") == sample_id), -1)
+
+            if entry_index == -1:
+                raise HTTPException(
+                    status_code=404, detail="Sample not found in index.")
+
+            entry = index_data[entry_index]
+            update_happened = False
+
+            # 3. Update metadata fields if provided in the payload
+            if payload.name is not None and payload.name != entry.get("name"):
+                entry["name"] = payload.name
+                update_happened = True
+
+            if payload.description is not None and payload.description != entry.get("description"):
+                entry["description"] = payload.description
+                update_happened = True
+
+            if payload.rating is not None and payload.rating != entry.get("rating"):
+                entry["rating"] = payload.rating
+                update_happened = True
+
+            if not update_happened:
+                return {"success": True, "id": sample_id, "action": "no_change", "message": "No new data provided to update."}
+
+            # 4. Write the updated index back to GCS
+            await run_io(_write_json_sync, index_path, index_data)
+
+            # 5. Clear relevant cache
+            await cache.delete("library:sample")
+            await cache.delete("library:all")
+
+            return {"success": True, "id": sample_id, "action": "metadata_updated"}
+
+        except HTTPException:
+            raise  # Re-raise FastAPI exceptions
+        except Exception as e:
+            logging.error(
+                f"Failed to update sample metadata for {sample_id}: {e}")
+            raise HTTPException(
+                status_code=500, detail=f"Failed to update sample metadata: {str(e)}")
+
 # --- 5. SMART SYNC (The "Magic" Button) ---
 
+
 @app.post("/api/admin/sync")
 async def sync_gcs_storage():
     """
@@ -412,7 +548,8 @@ async def sync_gcs_storage():
 
     async with INDEX_LOCK:
         for item_type, config in STORAGE_MAP.items():
-            if item_type == "default": continue
+            if item_type == "default":
+                continue
 
             added = 0
             removed = 0
@@ -427,7 +564,8 @@ async def sync_gcs_storage():
                 for b in blobs:
                     # Remove the folder prefix to get just filename (e.g., "123.json")
                     fname = b.name.replace(config["folder"], "")
-                    if fname and not b.name.endswith(config["index"]): # Ensure it's not the index file
+                    # Ensure it's not the index file
+                    if fname and not b.name.endswith(config["index"]):
                         actual_files.append(fname)
 
                 # 2. Get Current Index
@@ -450,7 +588,8 @@ async def sync_gcs_storage():
                     if filename not in index_map:
                         # Create new entry
                         new_entry = {
-                            "id": str(uuid.uuid4()), # Generate new ID or parse from filename if possible
+                            # Generate new ID or parse from filename if possible
+                            "id": str(uuid.uuid4()),
                             "filename": filename,
                             "type": item_type,
                             "date": datetime.now().strftime("%Y-%m-%d"),
@@ -462,11 +601,15 @@ async def sync_gcs_storage():
                         # If JSON, peek inside for metadata
                         if filename.endswith(".json") and item_type in ["song", "pattern", "bank"]:
                             try:
-                                b = bucket.blob(f"{config['folder']}{filename}")
+                                b = bucket.blob(
+                                    f"{config['folder']}{filename}")
                                 content = json.loads(b.download_as_text())
-                                if "name" in content: new_entry["name"] = content["name"]
-                                if "author" in content: new_entry["author"] = content["author"]
-                            except: pass
+                                if "name" in content:
+                                    new_entry["name"] = content["name"]
+                                if "author" in content:
+                                    new_entry["author"] = content["author"]
+                            except:
+                                pass
 
                         new_index.insert(0, new_entry)
                         added += 1
@@ -475,7 +618,8 @@ async def sync_gcs_storage():
                 if added > 0 or removed > 0:
                     await run_io(_write_json_sync, config["index"], new_index)
 
-                report[item_type] = {"added": added, "removed": removed, "status": "synced"}
+                report[item_type] = {"added": added,
+                                     "removed": removed, "status": "synced"}
 
             except Exception as e:
                 report[item_type] = {"error": str(e)}
@@ -484,4 +628,4 @@ async def sync_gcs_storage():
         return report
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)