Codex changes

.venv/Lib/site-packages/gradio/hash_seed.txt

@@ -0,0 +1 @@
+72a123ea2cd04be7b7f20053c7e03c99

backend/api/notebooks.py

@@ -1,27 +1,61 @@
-from fastapi import APIRouter, HTTPException
-from backend.models.schemas import NotebookCreate, NotebookOut
+from typing import List
+
+from fastapi import APIRouter, HTTPException, Query
+
+from backend.models.schemas import NotebookCreate, NotebookOut, NotebookRename
 from backend.services.storage import NotebookStore
 
 router = APIRouter()
 store = NotebookStore(base_dir="data")
 
 
+@router.get("/", response_model=List[NotebookOut])
+def list_notebooks(user_id: str = Query(...)) -> List[NotebookOut]:
+    try:
+        return store.list(user_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
 @router.post("/", response_model=NotebookOut)
 def create_notebook(payload: NotebookCreate) -> NotebookOut:
-    return store.create(payload)
+    try:
+        return store.create(payload)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
 @router.get("/{notebook_id}", response_model=NotebookOut)
-def get_notebook(notebook_id: str) -> NotebookOut:
-    notebook = store.get(notebook_id)
+def get_notebook(notebook_id: str, user_id: str = Query(...)) -> NotebookOut:
+    try:
+        notebook = store.get(user_id, notebook_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    if not notebook:
+        raise HTTPException(status_code=404, detail="Notebook not found")
+    return notebook
+
+
+@router.patch("/{notebook_id}", response_model=NotebookOut)
+def rename_notebook(notebook_id: str, payload: NotebookRename) -> NotebookOut:
+    try:
+        notebook = store.rename(payload.user_id, notebook_id, payload.name)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
     if not notebook:
         raise HTTPException(status_code=404, detail="Notebook not found")
     return notebook
 
 
 @router.delete("/{notebook_id}")
-def delete_notebook(notebook_id: str) -> dict:
-    deleted = store.delete(notebook_id)
+def delete_notebook(notebook_id: str, user_id: str = Query(...)) -> dict:
+    try:
+        deleted = store.delete(user_id, notebook_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
     if not deleted:
         raise HTTPException(status_code=404, detail="Notebook not found")
     return {"deleted": True}

backend/models/schemas.py

@@ -6,7 +6,14 @@ class NotebookCreate(BaseModel):
     name: str
 
 
+class NotebookRename(BaseModel):
+    user_id: str
+    name: str
+
+
 class NotebookOut(BaseModel):
     notebook_id: str
     user_id: str
     name: str
+    created_at: str
+    updated_at: str

backend/services/storage.py

@@ -1,7 +1,10 @@
 import json
+import re
+import shutil
 import uuid
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 from backend.models.schemas import NotebookCreate, NotebookOut
 
@@ -11,38 +14,135 @@ class NotebookStore:
         self.base_dir = Path(base_dir)
         self.base_dir.mkdir(parents=True, exist_ok=True)
 
-    def _notebook_path(self, notebook_id: str) -> Path:
-        return self.base_dir / notebook_id
+    def _validate_user_id(self, user_id: str) -> str:
+        if not re.fullmatch(r"[A-Za-z0-9._@-]+", user_id):
+            raise ValueError("Invalid user_id")
+        return user_id
+
+    def _users_root(self) -> Path:
+        return self.base_dir / "users"
+
+    def _user_root(self, user_id: str) -> Path:
+        return self._users_root() / self._validate_user_id(user_id)
+
+    def _notebooks_root(self, user_id: str) -> Path:
+        return self._user_root(user_id) / "notebooks"
+
+    def _index_path(self, user_id: str) -> Path:
+        return self._notebooks_root(user_id) / "index.json"
+
+    def _notebook_path(self, user_id: str, notebook_id: str) -> Path:
+        return self._notebooks_root(user_id) / notebook_id
+
+    def _meta_path(self, user_id: str, notebook_id: str) -> Path:
+        return self._notebook_path(user_id, notebook_id) / "meta.json"
+
+    def _now(self) -> str:
+        return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+    def _ensure_user_tree(self, user_id: str) -> None:
+        self._notebooks_root(user_id).mkdir(parents=True, exist_ok=True)
+
+    def _read_json(self, path: Path, default):
+        if not path.exists():
+            return default
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def _write_json(self, path: Path, data: object) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def _load_index(self, user_id: str) -> List[dict]:
+        self._ensure_user_tree(user_id)
+        data = self._read_json(self._index_path(user_id), default=[])
+        if isinstance(data, list):
+            return [item for item in data if isinstance(item, dict)]
+        return []
+
+    def _save_index(self, user_id: str, items: List[dict]) -> None:
+        self._write_json(self._index_path(user_id), items)
+
+    def _initialize_notebook_dirs(self, notebook_dir: Path) -> None:
+        for rel in [
+            "files_raw",
+            "files_extracted",
+            "chroma",
+            "chat",
+            "artifacts/reports",
+            "artifacts/quizzes",
+            "artifacts/podcasts",
+        ]:
+            (notebook_dir / rel).mkdir(parents=True, exist_ok=True)
+        (notebook_dir / "chat" / "messages.jsonl").touch(exist_ok=True)
 
     def create(self, payload: NotebookCreate) -> NotebookOut:
+        user_id = self._validate_user_id(payload.user_id)
+        self._ensure_user_tree(user_id)
+
         notebook_id = str(uuid.uuid4())
-        notebook_dir = self._notebook_path(notebook_id)
+        notebook_dir = self._notebook_path(user_id, notebook_id)
         notebook_dir.mkdir(parents=True, exist_ok=False)
+        self._initialize_notebook_dirs(notebook_dir)
+
+        now = self._now()
         data = {
             "notebook_id": notebook_id,
-            "user_id": payload.user_id,
+            "user_id": user_id,
             "name": payload.name,
+            "created_at": now,
+            "updated_at": now,
         }
-        (notebook_dir / "meta.json").write_text(json.dumps(data, indent=2))
+        self._write_json(notebook_dir / "meta.json", data)
+
+        index = self._load_index(user_id)
+        index.append(data)
+        self._save_index(user_id, index)
         return NotebookOut(**data)
 
-    def get(self, notebook_id: str) -> Optional[NotebookOut]:
-        notebook_dir = self._notebook_path(notebook_id)
-        meta_path = notebook_dir / "meta.json"
+    def list(self, user_id: str) -> List[NotebookOut]:
+        self._validate_user_id(user_id)
+        return [NotebookOut(**item) for item in self._load_index(user_id)]
+
+    def get(self, user_id: str, notebook_id: str) -> Optional[NotebookOut]:
+        user_id = self._validate_user_id(user_id)
+        meta_path = self._meta_path(user_id, notebook_id)
         if not meta_path.exists():
             return None
-        data = json.loads(meta_path.read_text())
+        data = self._read_json(meta_path, default=None)
+        if not isinstance(data, dict) or data.get("user_id") != user_id:
+            return None
         return NotebookOut(**data)
 
-    def delete(self, notebook_id: str) -> bool:
-        notebook_dir = self._notebook_path(notebook_id)
-        if not notebook_dir.exists():
+    def rename(self, user_id: str, notebook_id: str, name: str) -> Optional[NotebookOut]:
+        notebook = self.get(user_id, notebook_id)
+        if notebook is None:
+            return None
+
+        updated = notebook.model_dump()
+        updated["name"] = name
+        updated["updated_at"] = self._now()
+        self._write_json(self._meta_path(user_id, notebook_id), updated)
+
+        index = self._load_index(user_id)
+        for item in index:
+            if item.get("notebook_id") == notebook_id:
+                item.update(updated)
+                break
+        self._save_index(user_id, index)
+        return NotebookOut(**updated)
+
+    def delete(self, user_id: str, notebook_id: str) -> bool:
+        user_id = self._validate_user_id(user_id)
+        notebook_dir = self._notebook_path(user_id, notebook_id)
+        if not notebook_dir.exists() or self.get(user_id, notebook_id) is None:
             return False
-        for child in notebook_dir.rglob("*"):
-            if child.is_file():
-                child.unlink()
-        for child in sorted(notebook_dir.rglob("*"), reverse=True):
-            if child.is_dir():
-                child.rmdir()
-        notebook_dir.rmdir()
+
+        shutil.rmtree(notebook_dir)
+
+        index = [
+            item
+            for item in self._load_index(user_id)
+            if item.get("notebook_id") != notebook_id
+        ]
+        self._save_index(user_id, index)
         return True

requirements.txt

@@ -1,4 +1,7 @@
-fastapi
-uvicorn
-pydantic
-gradio
+huggingface_hub
+sentence-transformers
+chromadb
+pypdf
+python-pptx
+beautifulsoup4
+requests

tests/test_api_notebooks.py

@@ -1,12 +1,20 @@
 from fastapi.testclient import TestClient
 
 from backend.app import app
+from backend.api import notebooks as notebooks_api
+from backend.services.storage import NotebookStore
 
 
 client = TestClient(app)
 
 
-def test_create_and_get_notebook():
+def setup_function():
+    notebooks_api.store = NotebookStore(base_dir="tests_tmp_data")
+
+
+def test_create_list_get_rename_delete_notebook(tmp_path):
+    notebooks_api.store = NotebookStore(base_dir=str(tmp_path))
+
     payload = {"user_id": "u1", "name": "Notebook 1"}
     resp = client.post("/api/notebooks/", json=payload)
     assert resp.status_code == 200
@@ -16,12 +24,34 @@ def test_create_and_get_notebook():
     assert "notebook_id" in data
 
     notebook_id = data["notebook_id"]
-    resp_get = client.get(f"/api/notebooks/{notebook_id}")
+
+    resp_list = client.get("/api/notebooks/", params={"user_id": "u1"})
+    assert resp_list.status_code == 200
+    listed = resp_list.json()
+    assert len(listed) == 1
+    assert listed[0]["notebook_id"] == notebook_id
+
+    resp_get = client.get(f"/api/notebooks/{notebook_id}", params={"user_id": "u1"})
     assert resp_get.status_code == 200
     data_get = resp_get.json()
     assert data_get["notebook_id"] == notebook_id
 
+    resp_wrong_user = client.get(f"/api/notebooks/{notebook_id}", params={"user_id": "u2"})
+    assert resp_wrong_user.status_code == 404
+
+    resp_rename = client.patch(
+        f"/api/notebooks/{notebook_id}",
+        json={"user_id": "u1", "name": "Renamed"},
+    )
+    assert resp_rename.status_code == 200
+    assert resp_rename.json()["name"] == "Renamed"
+
+    resp_delete = client.delete(f"/api/notebooks/{notebook_id}", params={"user_id": "u1"})
+    assert resp_delete.status_code == 200
+    assert resp_delete.json() == {"deleted": True}
+
 
-def test_get_missing_notebook():
-    resp = client.get("/api/notebooks/missing")
+def test_get_missing_notebook(tmp_path):
+    notebooks_api.store = NotebookStore(base_dir=str(tmp_path))
+    resp = client.get("/api/notebooks/missing", params={"user_id": "u1"})
     assert resp.status_code == 404

tests/test_storage.py

@@ -1,17 +1,40 @@
-from backend.services.storage import NotebookStore
 from backend.models.schemas import NotebookCreate
+from backend.services.storage import NotebookStore
 
 
-def test_create_get_delete_notebook(tmp_path):
+def test_create_list_get_rename_delete_notebook(tmp_path):
     store = NotebookStore(base_dir=str(tmp_path))
+
     created = store.create(NotebookCreate(user_id="u1", name="Test"))
+    assert created.user_id == "u1"
+    assert created.created_at
+    assert created.updated_at
 
-    fetched = store.get(created.notebook_id)
+    notebooks = store.list("u1")
+    assert len(notebooks) == 1
+    assert notebooks[0].notebook_id == created.notebook_id
+
+    fetched = store.get("u1", created.notebook_id)
     assert fetched is not None
-    assert fetched.notebook_id == created.notebook_id
-    assert fetched.user_id == "u1"
     assert fetched.name == "Test"
 
-    deleted = store.delete(created.notebook_id)
+    renamed = store.rename("u1", created.notebook_id, "Renamed")
+    assert renamed is not None
+    assert renamed.name == "Renamed"
+
+    assert store.get("u2", created.notebook_id) is None
+
+    deleted = store.delete("u1", created.notebook_id)
     assert deleted is True
-    assert store.get(created.notebook_id) is None
+    assert store.get("u1", created.notebook_id) is None
+    assert store.list("u1") == []
+
+
+def test_invalid_user_id_rejected(tmp_path):
+    store = NotebookStore(base_dir=str(tmp_path))
+
+    try:
+        store.list("../bad")
+        assert False, "Expected ValueError"
+    except ValueError:
+        assert True