Rename owner id to user id (#59)

backend/db/models.py

@@ -176,11 +176,11 @@ def __repr__(self) -> str:
 
 
 def validate_extractor_owner(
-    session: Session, extractor_id: UUID, owner_id: UUID
+    session: Session, extractor_id: UUID, user_id: UUID
 ) -> Extractor:
     """Validate the extractor id."""
     extractor = (
-        session.query(Extractor).filter_by(uuid=extractor_id, owner_id=owner_id).first()
+        session.query(Extractor).filter_by(uuid=extractor_id, owner_id=user_id).first()
     )
     if extractor is None:
         return False

backend/server/api/examples.py

@@ -36,10 +36,10 @@ def create(
     create_request: CreateExample,
     *,
     session: Session = Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> CreateExampleResponse:
     """Endpoint to create an example."""
-    if not validate_extractor_owner(session, create_request["extractor_id"], owner_id):
+    if not validate_extractor_owner(session, create_request["extractor_id"], user_id):
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")
 
     instance = Example(
@@ -59,10 +59,10 @@ def list(
     limit: int = 10,
     offset: int = 0,
     session=Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> List[Any]:
     """Endpoint to get all examples."""
-    if not validate_extractor_owner(session, extractor_id, owner_id):
+    if not validate_extractor_owner(session, extractor_id, user_id):
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")
     return (
         session.query(Example)
@@ -76,11 +76,11 @@ def list(
 
 @router.delete("/{uuid}")
 def delete(
-    uuid: UUID, *, session: Session = Depends(get_session), owner_id: UUID = Cookie(...)
+    uuid: UUID, *, session: Session = Depends(get_session), user_id: UUID = Cookie(...)
 ) -> None:
     """Endpoint to delete an example."""
     extractor_id = session.query(Example).filter_by(uuid=str(uuid)).first().extractor_id
-    if not validate_extractor_owner(session, extractor_id, owner_id):
+    if not validate_extractor_owner(session, extractor_id, user_id):
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")
     session.query(Example).filter_by(uuid=str(uuid)).delete()
     session.commit()

backend/server/api/extract.py

@@ -27,7 +27,7 @@ async def extract_using_existing_extractor(
     file: Optional[UploadFile] = File(None),
     model_name: Optional[str] = Form(DEFAULT_MODEL),
     session: Session = Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> ExtractResponse:
     """Endpoint that is used with an existing extractor.
 
@@ -38,9 +38,7 @@ async def extract_using_existing_extractor(
         raise HTTPException(status_code=422, detail="No text or file provided.")
 
     extractor = (
-        session.query(Extractor)
-        .filter_by(uuid=extractor_id, owner_id=owner_id)
-        .scalar()
+        session.query(Extractor).filter_by(uuid=extractor_id, owner_id=user_id).scalar()
     )
     if extractor is None:
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")

backend/server/api/extractors.py

@@ -60,7 +60,7 @@ def share(
     uuid: UUID,
     *,
     session: Session = Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> ShareExtractorResponse:
     """Endpoint to share an extractor.
 
@@ -74,7 +74,7 @@ def share(
     Returns:
         The UUID for the shared extractor.
     """
-    if not validate_extractor_owner(session, uuid, owner_id):
+    if not validate_extractor_owner(session, uuid, user_id):
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")
     # Check if the extractor is already shared
     shared_extractor = (
@@ -110,13 +110,13 @@ def create(
     create_request: CreateExtractor,
     *,
     session: Session = Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> CreateExtractorResponse:
     """Endpoint to create an extractor."""
 
     instance = Extractor(
         name=create_request.name,
-        owner_id=owner_id,
+        owner_id=user_id,
         schema=create_request.json_schema,
         description=create_request.description,
         instruction=create_request.instruction,
@@ -128,11 +128,11 @@ def create(
 
 @router.get("/{uuid}")
 def get(
-    uuid: UUID, *, session: Session = Depends(get_session), owner_id: UUID = Cookie(...)
+    uuid: UUID, *, session: Session = Depends(get_session), user_id: UUID = Cookie(...)
 ) -> Dict[str, Any]:
     """Endpoint to get an extractor."""
     extractor = (
-        session.query(Extractor).filter_by(uuid=str(uuid), owner_id=owner_id).scalar()
+        session.query(Extractor).filter_by(uuid=str(uuid), owner_id=user_id).scalar()
     )
     if extractor is None:
         raise HTTPException(status_code=404, detail="Extractor not found for owner.")
@@ -151,12 +151,12 @@ def list(
     limit: int = 10,
     offset: int = 0,
     session=Depends(get_session),
-    owner_id: UUID = Cookie(...),
+    user_id: UUID = Cookie(...),
 ) -> List[Any]:
     """Endpoint to get all extractors."""
     return (
         session.query(Extractor)
-        .filter_by(owner_id=owner_id)
+        .filter_by(owner_id=user_id)
         .limit(limit)
         .offset(offset)
         .all()
@@ -165,8 +165,8 @@ def list(
 
 @router.delete("/{uuid}")
 def delete(
-    uuid: UUID, *, session: Session = Depends(get_session), owner_id: UUID = Cookie(...)
+    uuid: UUID, *, session: Session = Depends(get_session), user_id: UUID = Cookie(...)
 ) -> None:
     """Endpoint to delete an extractor."""
-    session.query(Extractor).filter_by(uuid=str(uuid), owner_id=owner_id).delete()
+    session.query(Extractor).filter_by(uuid=str(uuid), owner_id=user_id).delete()
     session.commit()

backend/tests/unit_tests/api/test_api_defining_extractors.py

@@ -8,8 +8,8 @@ async def test_extractors_api() -> None:
     """This will test a few of the extractors API endpoints."""
     # First verify that the database is empty
     async with get_async_client() as client:
-        owner_id = str(uuid.uuid4())
-        cookies = {"owner_id": owner_id}
+        user_id = str(uuid.uuid4())
+        cookies = {"user_id": user_id}
         response = await client.get("/extractors", cookies=cookies)
         assert response.status_code == 200
         assert response.json() == []
@@ -32,7 +32,7 @@ async def test_extractors_api() -> None:
         assert len(get_response) == 1
 
         # Check cookies
-        bad_cookies = {"owner_id": str(uuid.uuid4())}
+        bad_cookies = {"user_id": str(uuid.uuid4())}
         bad_response = await client.get("/extractors", cookies=bad_cookies)
         assert bad_response.status_code == 200
         assert len(bad_response.json()) == 0
@@ -84,7 +84,7 @@ async def test_extractors_api() -> None:
         assert get_response.json() == []
 
         # Verify that we can create an extractor, including other properties
-        owner_id = str(uuid.uuid4())
+        user_id = str(uuid.uuid4())
         create_request = {
             "name": "my extractor",
             "description": "Test Description",
@@ -100,14 +100,14 @@ async def test_extractors_api() -> None:
         response_data = response.json()
         assert extractor_uuid == response_data["uuid"]
         assert "my extractor" == response_data["name"]
-        assert "owner_id" not in response_data
+        assert "user_id" not in response_data
 
 
 async def test_sharing_extractor() -> None:
     """Test sharing an extractor."""
     async with get_async_client() as client:
-        owner_id = str(uuid.uuid4())
-        cookies = {"owner_id": owner_id}
+        user_id = str(uuid.uuid4())
+        cookies = {"user_id": user_id}
         response = await client.get("/extractors", cookies=cookies)
         assert response.status_code == 200
         assert response.json() == []
@@ -138,7 +138,7 @@ async def test_sharing_extractor() -> None:
         assert response.json()["share_uuid"] == share_uuid
 
         # Check cookies
-        bad_cookies = {"owner_id": str(uuid.uuid4())}
+        bad_cookies = {"user_id": str(uuid.uuid4())}
         response = await client.post(
             f"/extractors/{uuid_str}/share", cookies=bad_cookies
         )

backend/tests/unit_tests/api/test_api_examples.py

@@ -15,8 +15,8 @@ async def test_examples_api() -> None:
     """Runs through a set of API calls to test the examples API."""
     async with get_async_client() as client:
         # First create an extractor
-        owner_id = str(uuid.uuid4())
-        cookies = {"owner_id": owner_id}
+        user_id = str(uuid.uuid4())
+        cookies = {"user_id": user_id}
         create_request = {
             "description": "Test Description",
             "name": "Test Name",
@@ -53,7 +53,7 @@ async def test_examples_api() -> None:
         example_id = response.json()["uuid"]
 
         # Check cookies
-        bad_cookies = {"owner_id": str(uuid.uuid4())}
+        bad_cookies = {"user_id": str(uuid.uuid4())}
         response = await client.post(
             "/examples", json=create_request, cookies=bad_cookies
         )

backend/tests/unit_tests/api/test_api_extract.py

@@ -41,8 +41,8 @@ def mock_embeddings(*args, **kwargs):
 async def test_extract_from_file() -> None:
     """Test extract from file API."""
     async with get_async_client() as client:
-        owner_id = str(uuid4())
-        cookies = {"owner_id": owner_id}
+        user_id = str(uuid4())
+        cookies = {"user_id": user_id}
         # Test with invalid extractor
         extractor_id = UUID(int=1027)  # 1027 is a good number.
         response = await client.post(
@@ -131,8 +131,8 @@ async def test_extract_from_file() -> None:
 
 
 async def test_extract_from_large_file() -> None:
-    owner_id = str(uuid4())
-    cookies = {"owner_id": owner_id}
+    user_id = str(uuid4())
+    cookies = {"user_id": user_id}
     async with get_async_client() as client:
         # First create an extractor
         create_request = {

docs/source/notebooks/earnings_call_example.ipynb

@@ -96,11 +96,11 @@
     "    period_duration: int = Field(..., description=\"Duration of period, in months\")\n",
     "    evidence: str = Field(..., description=\"Verbatim sentence of text where figure was found.\")\n",
     "\n",
-    "owner_id = str(uuid4())\n",
-    "cookies = {\"owner_id\": owner_id}\n",
+    "user_id = str(uuid4())\n",
+    "cookies = {\"user_id\": user_id}\n",
     "\n",
     "data = {\n",
-    "    \"owner_id\": owner_id,\n",
+    "    \"user_id\": user_id,\n",
     "    \"description\": \"Financial revenues and other figures.\",\n",
     "    \"schema\": FinancialData.schema(),\n",
     "    \"instruction\": (\n",

docs/source/notebooks/quick_start.ipynb

@@ -206,8 +206,8 @@
    "outputs": [],
    "source": [
     "url = \"http://localhost:8000\"\n",
-    "owner_id = str(uuid4())  # indicates owner for extractor\n",
-    "cookies = {\"owner_id\": owner_id}"
+    "user_id = str(uuid4())  # indicates owner for extractor\n",
+    "cookies = {\"user_id\": user_id}"
    ]
   },
   {

frontend/middleware.ts

@@ -5,8 +5,7 @@ import { v4 as uuidv4 } from "uuid";
 // Automatically set a 'user_id' cookie if one doesn't exist
 // This function will run on every page request, so we can
 // guarantee that a 'user_id' cookie will always be set.
-/* TODO: Change this to 'user_id' */
-const USER_ID_COOKIE_KEY = "owner_id";
+const USER_ID_COOKIE_KEY = "user_id";
 
 export function middleware(request: NextRequest) {
   const response = NextResponse.next();