Add/study attach detach

src/database/studies.py

@@ -1,3 +1,4 @@
+import re
 from datetime import datetime
 from typing import cast
 
@@ -121,3 +122,43 @@ def attach_run_to_study(run_id: int, study_id: int, user: User, expdb: Connectio
         ),
         parameters={"study_id": study_id, "run_id": run_id, "user_id": user.user_id},
     )
+
+
+def attach_tasks_to_study(
+    study_id: int,
+    task_ids: list[int],
+    user: User,
+    connection: Connection,
+) -> None:
+    to_link = [(study_id, task_id, user.user_id) for task_id in task_ids]
+    try:
+        connection.execute(
+            text(
+                """
+                INSERT INTO task_study (study_id, task_id, uploader)
+                VALUES (:study_id, :task_id, :user_id)
+                """,
+            ),
+            parameters=[{"study_id": s, "task_id": t, "user_id": u} for s, t, u in to_link],
+        )
+    except Exception as e:
+        (msg,) = e.args
+        if match := re.search(r"Duplicate entry '(\d+)-(\d+)' for key 'task_study.PRIMARY'", msg):
+            msg = f"Task {match.group(2)} is already attached to study {match.group(1)}."
+        elif "a foreign key constraint fails" in msg:
+            # The message and exception have no information about which task is invalid.
+            msg = "One or more of the tasks do not exist."
+        elif "Out of range value for column 'task_id'" in msg:
+            msg = "One specified ids is not in the valid range of task ids."
+        else:
+            raise
+        raise ValueError(msg) from e
+
+
+def attach_runs_to_study(
+    study_id: int,  # noqa: ARG001
+    task_ids: list[int],  # noqa: ARG001
+    user: User,  # noqa: ARG001
+    connection: Connection,  # noqa: ARG001
+) -> None:
+    raise NotImplementedError

src/routers/openml/study.py

@@ -4,16 +4,19 @@
 from core.formatting import _str_to_bool
 from database.studies import (
     attach_run_to_study,
+    attach_runs_to_study,
     attach_task_to_study,
+    attach_tasks_to_study,
     get_study_by_alias,
     get_study_by_id,
     get_study_data,
 )
 from database.studies import create_study as db_create_study
 from database.users import User, UserGroup
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Body, Depends, HTTPException
+from pydantic import BaseModel
 from schemas.core import Visibility
-from schemas.study import CreateStudy, Study, StudyType
+from schemas.study import CreateStudy, Study, StudyStatus, StudyType
 from sqlalchemy import Connection, Row
 
 from routers.dependencies import expdb_connection, fetch_user
@@ -31,7 +34,10 @@ def _get_study_raise_otherwise(id_or_alias: int | str, user: User | None, expdb:
         raise HTTPException(status_code=http.client.NOT_FOUND, detail="Study not found.")
     if study.visibility == Visibility.PRIVATE:
         if user is None:
-            raise HTTPException(status_code=http.client.UNAUTHORIZED, detail="Study is private.")
+            raise HTTPException(
+                status_code=http.client.UNAUTHORIZED,
+                detail="Must authenticate for private study.",
+            )
         if study.creator != user.user_id and UserGroup.ADMIN not in user.groups:
             raise HTTPException(status_code=http.client.FORBIDDEN, detail="Study is private.")
     if _str_to_bool(study.legacy):
@@ -42,6 +48,46 @@ def _get_study_raise_otherwise(id_or_alias: int | str, user: User | None, expdb:
     return study
 
 
+class AttachDetachResponse(BaseModel):
+    study_id: int
+    main_entity_type: StudyType
+
+
+@router.post("/attach")
+def attach_to_study(
+    study_id: Annotated[int, Body()],
+    entity_ids: Annotated[list[int], Body()],
+    user: Annotated[User | None, Depends(fetch_user)] = None,
+    expdb: Annotated[Connection, Depends(expdb_connection)] = None,
+) -> AttachDetachResponse:
+    if user is None:
+        raise HTTPException(status_code=http.client.UNAUTHORIZED, detail="User not found.")
+    study = _get_study_raise_otherwise(study_id, user, expdb)
+    # PHP lets *anyone* edit *any* study. We're not going to do that.
+    if study.creator != user.user_id and UserGroup.ADMIN not in user.groups:
+        raise HTTPException(
+            status_code=http.client.FORBIDDEN,
+            detail="Study can only be edited by its creator.",
+        )
+    if study.status != StudyStatus.IN_PREPARATION:
+        raise HTTPException(
+            status_code=http.client.FORBIDDEN,
+            detail="Study can only be edited while in preparation.",
+        )
+
+    # We let the database handle the constraints on whether
+    # the entity is already attached or if it even exists.
+    attach = attach_tasks_to_study if study.type_ == StudyType.TASK else attach_runs_to_study
+    try:
+        attach(study_id, entity_ids, user, expdb)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=http.client.CONFLICT,
+            detail=str(e),
+        ) from None
+    return AttachDetachResponse(study_id=study_id, main_entity_type=study.type_)
+
+
 @router.post("/")
 def create_study(
     study: CreateStudy,
@@ -88,6 +134,7 @@ def get_study(
     study = _get_study_raise_otherwise(alias_or_id, user, expdb)
     study_data = get_study_data(study, expdb)
     return Study(
+        _legacy=_str_to_bool(study.legacy),
         id_=study.id,
         name=study.name,
         alias=study.alias,

src/schemas/study.py

@@ -18,6 +18,7 @@ class StudyStatus(StrEnum):
 
 
 class Study(BaseModel):
+    legacy: bool = Field(default=False, exclude=True)
     id_: int = Field(serialization_alias="id")
     name: str
     alias: str | None

tests/routers/openml/study_test.py

@@ -1,5 +1,9 @@
+import http.client
 from datetime import datetime
 
+import httpx
+from schemas.study import StudyType
+from sqlalchemy import Connection, text
 from starlette.testclient import TestClient
 
 
@@ -494,3 +498,75 @@ def test_create_task_study(py_api: TestClient) -> None:
     )
     assert creation_date.date() == datetime.now().date()
     assert new_study == expected
+
+
+def _attach_tasks_to_study(
+    study_id: int,
+    task_ids: list[int],
+    api_key: str,
+    py_api: TestClient,
+    expdb_test: Connection,
+) -> httpx.Response:
+    # Adding requires the study to be in preparation,
+    # but the current snapshot has no in-preparation studies.
+    expdb_test.execute(text("UPDATE study SET status = 'in_preparation' WHERE id = 1"))
+    return py_api.post(
+        f"/studies/attach?api_key={api_key}",
+        json={"study_id": study_id, "entity_ids": task_ids},
+    )
+
+
+def test_attach_task_to_study(py_api: TestClient, expdb_test: Connection) -> None:
+    response = _attach_tasks_to_study(
+        study_id=1,
+        task_ids=[2, 3, 4],
+        api_key="AD000000000000000000000000000000",
+        py_api=py_api,
+        expdb_test=expdb_test,
+    )
+    assert response.status_code == http.client.OK
+    assert response.json() == {"study_id": 1, "main_entity_type": StudyType.TASK}
+
+
+def test_attach_task_to_study_needs_owner(py_api: TestClient, expdb_test: Connection) -> None:
+    expdb_test.execute(text("UPDATE study SET status = 'in_preparation' WHERE id = 1"))
+    response = _attach_tasks_to_study(
+        study_id=1,
+        task_ids=[2, 3, 4],
+        api_key="00000000000000000000000000000000",
+        py_api=py_api,
+        expdb_test=expdb_test,
+    )
+    assert response.status_code == http.client.FORBIDDEN
+
+
+def test_attach_task_to_study_already_linked_raises(
+    py_api: TestClient,
+    expdb_test: Connection,
+) -> None:
+    expdb_test.execute(text("UPDATE study SET status = 'in_preparation' WHERE id = 1"))
+    response = _attach_tasks_to_study(
+        study_id=1,
+        task_ids=[1, 3, 4],
+        api_key="AD000000000000000000000000000000",
+        py_api=py_api,
+        expdb_test=expdb_test,
+    )
+    assert response.status_code == http.client.CONFLICT
+    assert response.json() == {"detail": "Task 1 is already attached to study 1."}
+
+
+def test_attach_task_to_study_but_task_not_exist_raises(
+    py_api: TestClient,
+    expdb_test: Connection,
+) -> None:
+    expdb_test.execute(text("UPDATE study SET status = 'in_preparation' WHERE id = 1"))
+    response = _attach_tasks_to_study(
+        study_id=1,
+        task_ids=[80123, 78914],
+        api_key="AD000000000000000000000000000000",
+        py_api=py_api,
+        expdb_test=expdb_test,
+    )
+    assert response.status_code == http.client.CONFLICT
+    assert response.json() == {"detail": "One or more of the tasks do not exist."}