fractal-server 2.12.1__py3-none-any.whl → 2.13.1__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.12.1"
+__VERSION__ = "2.13.1"

fractal_server/app/models/security.py

@@ -12,6 +12,7 @@
 from datetime import datetime
 from typing import Optional
 
+from pydantic import ConfigDict
 from pydantic import EmailStr
 from sqlalchemy import Column
 from sqlalchemy.types import DateTime
@@ -50,13 +51,11 @@ class OAuthAccount(SQLModel, table=True):
     user: Optional["UserOAuth"] = Relationship(back_populates="oauth_accounts")
     oauth_name: str = Field(index=True, nullable=False)
     access_token: str = Field(nullable=False)
-    expires_at: Optional[int] = Field(nullable=True)
-    refresh_token: Optional[str] = Field(nullable=True)
+    expires_at: Optional[int] = Field(nullable=True, default=None)
+    refresh_token: Optional[str] = Field(nullable=True, default=None)
     account_id: str = Field(index=True, nullable=False)
     account_email: str = Field(nullable=False)
-
-    class Config:
-        orm_mode = True
+    model_config = ConfigDict(from_attributes=True)
 
 
 class UserOAuth(SQLModel, table=True):
@@ -88,11 +87,11 @@ class UserOAuth(SQLModel, table=True):
         sa_column_kwargs={"unique": True, "index": True}, nullable=False
     )
     hashed_password: str
-    is_active: bool = Field(True, nullable=False)
-    is_superuser: bool = Field(False, nullable=False)
-    is_verified: bool = Field(False, nullable=False)
+    is_active: bool = Field(default=True, nullable=False)
+    is_superuser: bool = Field(default=False, nullable=False)
+    is_verified: bool = Field(default=False, nullable=False)
 
-    username: Optional[str]
+    username: Optional[str] = None
 
     oauth_accounts: list["OAuthAccount"] = Relationship(
         back_populates="user",
@@ -105,9 +104,7 @@ class UserOAuth(SQLModel, table=True):
     settings: Optional[UserSettings] = Relationship(
         sa_relationship_kwargs=dict(lazy="selectin", cascade="all, delete")
     )
-
-    class Config:
-        orm_mode = True
+    model_config = ConfigDict(from_attributes=True)
 
 
 class UserGroup(SQLModel, table=True):

fractal_server/app/models/v2/__init__.py

@@ -2,6 +2,8 @@
 v2 `models` module
 """
 from ..linkuserproject import LinkUserProjectV2
+from .accounting import AccountingRecord
+from .accounting import AccountingRecordSlurm
 from .dataset import DatasetV2
 from .job import JobV2
 from .project import ProjectV2
@@ -12,6 +14,8 @@ from .workflow import WorkflowV2
 from .workflowtask import WorkflowTaskV2
 
 __all__ = [
+    "AccountingRecord",
+    "AccountingRecordSlurm",
     "LinkUserProjectV2",
     "DatasetV2",
     "JobV2",

fractal_server/app/models/v2/accounting.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.types import DateTime
+from sqlmodel import Field
+from sqlmodel import SQLModel
+
+from ....utils import get_timestamp
+
+
+class AccountingRecord(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    user_id: int = Field(foreign_key="user_oauth.id", nullable=False)
+    timestamp: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+    num_tasks: int
+    num_new_images: int
+
+
+class AccountingRecordSlurm(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    user_id: int = Field(foreign_key="user_oauth.id", nullable=False)
+    timestamp: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+    slurm_job_ids: list[int] = Field(
+        default_factory=list,
+        sa_column=Column(ARRAY(Integer)),
+    )

fractal_server/app/models/v2/dataset.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from typing import Any
 from typing import Optional
 
+from pydantic import ConfigDict
 from sqlalchemy import Column
 from sqlalchemy.types import DateTime
 from sqlalchemy.types import JSON
@@ -14,8 +15,7 @@ from fractal_server.images.models import AttributeFiltersType
 
 
 class DatasetV2(SQLModel, table=True):
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     id: Optional[int] = Field(default=None, primary_key=True)
     name: str

fractal_server/app/models/v2/job.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from typing import Any
 from typing import Optional
 
+from pydantic import ConfigDict
 from sqlalchemy import Column
 from sqlalchemy.types import DateTime
 from sqlalchemy.types import JSON
@@ -14,16 +15,17 @@ from fractal_server.images.models import AttributeFiltersType
 
 
 class JobV2(SQLModel, table=True):
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     id: Optional[int] = Field(default=None, primary_key=True)
-    project_id: Optional[int] = Field(foreign_key="projectv2.id")
-    workflow_id: Optional[int] = Field(foreign_key="workflowv2.id")
-    dataset_id: Optional[int] = Field(foreign_key="datasetv2.id")
+    project_id: Optional[int] = Field(foreign_key="projectv2.id", default=None)
+    workflow_id: Optional[int] = Field(
+        foreign_key="workflowv2.id", default=None
+    )
+    dataset_id: Optional[int] = Field(foreign_key="datasetv2.id", default=None)
 
     user_email: str = Field(nullable=False)
-    slurm_account: Optional[str]
+    slurm_account: Optional[str] = None
 
     dataset_dump: dict[str, Any] = Field(
         sa_column=Column(JSON, nullable=False)
@@ -35,9 +37,9 @@ class JobV2(SQLModel, table=True):
         sa_column=Column(JSON, nullable=False)
     )
 
-    worker_init: Optional[str]
-    working_dir: Optional[str]
-    working_dir_user: Optional[str]
+    worker_init: Optional[str] = None
+    working_dir: Optional[str] = None
+    working_dir_user: Optional[str] = None
     first_task_index: int
     last_task_index: int
 

fractal_server/app/models/v2/task.py

@@ -1,7 +1,6 @@
 from typing import Any
 from typing import Optional
 
-from pydantic import HttpUrl
 from sqlalchemy import Column
 from sqlalchemy.types import JSON
 from sqlmodel import Field
@@ -31,9 +30,9 @@ class TaskV2(SQLModel, table=True):
     args_schema_parallel: Optional[dict[str, Any]] = Field(
         sa_column=Column(JSON), default=None
     )
-    args_schema_version: Optional[str]
+    args_schema_version: Optional[str] = None
     docs_info: Optional[str] = None
-    docs_link: Optional[HttpUrl] = None
+    docs_link: Optional[str] = None
 
     input_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})
     output_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})

fractal_server/app/models/v2/task_group.py

@@ -22,7 +22,9 @@ class TaskGroupV2(SQLModel, table=True):
     )
 
     user_id: int = Field(foreign_key="user_oauth.id")
-    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
+    user_group_id: Optional[int] = Field(
+        foreign_key="usergroup.id", default=None
+    )
 
     origin: str
     pkg_name: str
@@ -97,7 +99,9 @@ class TaskGroupActivityV2(SQLModel, table=True):
 
     id: Optional[int] = Field(default=None, primary_key=True)
     user_id: int = Field(foreign_key="user_oauth.id")
-    taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
+    taskgroupv2_id: Optional[int] = Field(
+        default=None, foreign_key="taskgroupv2.id"
+    )
     timestamp_started: datetime = Field(
         default_factory=get_timestamp,
         sa_column=Column(DateTime(timezone=True), nullable=False),

fractal_server/app/models/v2/workflowtask.py

@@ -1,6 +1,7 @@
 from typing import Any
 from typing import Optional
 
+from pydantic import ConfigDict
 from sqlalchemy import Column
 from sqlalchemy.types import JSON
 from sqlmodel import Field
@@ -11,18 +12,24 @@ from .task import TaskV2
 
 
 class WorkflowTaskV2(SQLModel, table=True):
-    class Config:
-        arbitrary_types_allowed = True
-        fields = {"parent": {"exclude": True}}
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     id: Optional[int] = Field(default=None, primary_key=True)
 
     workflow_id: int = Field(foreign_key="workflowv2.id")
-    order: Optional[int]
-    meta_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
-    meta_non_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
-    args_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
-    args_non_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
+    order: Optional[int] = None
+    meta_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
+    meta_non_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
+    args_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
+    args_non_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
 
     type_filters: dict[str, bool] = Field(
         sa_column=Column(JSON, nullable=False, server_default="{}")

fractal_server/app/routes/admin/v2/__init__.py

@@ -3,6 +3,8 @@
 """
 from fastapi import APIRouter
 
+from .accounting import router as accounting_router
+from .impersonate import router as impersonate_router
 from .job import router as job_router
 from .project import router as project_router
 from .task import router as task_router
@@ -11,6 +13,7 @@ from .task_group_lifecycle import router as task_group_lifecycle_router
 
 router_admin_v2 = APIRouter()
 
+router_admin_v2.include_router(accounting_router, prefix="/accounting")
 router_admin_v2.include_router(job_router, prefix="/job")
 router_admin_v2.include_router(project_router, prefix="/project")
 router_admin_v2.include_router(task_router, prefix="/task")
@@ -18,3 +21,4 @@ router_admin_v2.include_router(task_group_router, prefix="/task-group")
 router_admin_v2.include_router(
     task_group_lifecycle_router, prefix="/task-group"
 )
+router_admin_v2.include_router(impersonate_router, prefix="/impersonate")

fractal_server/app/routes/admin/v2/accounting.py

@@ -0,0 +1,108 @@
+from itertools import chain
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Query
+from fastapi import status
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from pydantic.types import AwareDatetime
+from sqlmodel import func
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import AccountingRecord
+from fractal_server.app.models.v2 import AccountingRecordSlurm
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.schemas.v2 import AccountingRecordRead
+
+
+class AccountingQuery(BaseModel):
+    user_id: Optional[int] = None
+    timestamp_min: Optional[AwareDatetime] = None
+    timestamp_max: Optional[AwareDatetime] = None
+
+
+class AccountingPage(BaseModel):
+    total_count: int
+    page_size: int
+    current_page: int
+    records: list[AccountingRecordRead]
+
+
+router = APIRouter()
+
+
+@router.post("/", response_model=AccountingPage)
+async def query_accounting(
+    query: AccountingQuery,
+    # pagination
+    page: int = Query(default=1, ge=1),
+    page_size: Optional[int] = Query(default=None, ge=1),
+    # dependencies
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> AccountingPage:
+
+    if page_size is None and page > 1:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(f"Invalid pagination parameters: {page=}, {page_size=}."),
+        )
+
+    stm = select(AccountingRecord).order_by(AccountingRecord.id)
+    stm_count = select(func.count(AccountingRecord.id))
+    if query.user_id is not None:
+        stm = stm.where(AccountingRecord.user_id == query.user_id)
+        stm_count = stm_count.where(AccountingRecord.user_id == query.user_id)
+    if query.timestamp_min is not None:
+        stm = stm.where(AccountingRecord.timestamp >= query.timestamp_min)
+        stm_count = stm_count.where(
+            AccountingRecord.timestamp >= query.timestamp_min
+        )
+    if query.timestamp_max is not None:
+        stm = stm.where(AccountingRecord.timestamp <= query.timestamp_max)
+        stm_count = stm_count.where(
+            AccountingRecord.timestamp <= query.timestamp_max
+        )
+    if page_size is not None:
+        stm = stm.offset((page - 1) * page_size).limit(page_size)
+
+    res = await db.execute(stm)
+    records = res.scalars().all()
+    res_total_count = await db.execute(stm_count)
+    total_count = res_total_count.scalar()
+
+    actual_page_size = page_size or len(records)
+    return AccountingPage(
+        total_count=total_count,
+        page_size=actual_page_size,
+        current_page=page,
+        records=[record.model_dump() for record in records],
+    )
+
+
+@router.post("/slurm/")
+async def query_accounting_slurm(
+    query: AccountingQuery,
+    # dependencies
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> JSONResponse:
+
+    stm = select(AccountingRecordSlurm.slurm_job_ids)
+    if query.user_id is not None:
+        stm = stm.where(AccountingRecordSlurm.user_id == query.user_id)
+    if query.timestamp_min is not None:
+        stm = stm.where(AccountingRecordSlurm.timestamp >= query.timestamp_min)
+    if query.timestamp_max is not None:
+        stm = stm.where(AccountingRecordSlurm.timestamp <= query.timestamp_max)
+
+    res = await db.execute(stm)
+    nested_slurm_job_ids = res.scalars().all()
+    aggregated_slurm_job_ids = list(chain(*nested_slurm_job_ids))
+    return JSONResponse(content=aggregated_slurm_job_ids, status_code=200)

fractal_server/app/routes/admin/v2/impersonate.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi.responses import JSONResponse
+from fastapi_users.authentication import JWTStrategy
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.routes.auth._aux_auth import _user_or_404
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
+router = APIRouter()
+
+
+@router.get("/{user_id}/")
+async def impersonate_user(
+    user_id: int,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> JSONResponse:
+    user = await _user_or_404(user_id, db)
+
+    settings = Inject(get_settings)
+    jwt_strategy = JWTStrategy(
+        secret=settings.JWT_SECRET_KEY,  # type: ignore
+        lifetime_seconds=7200,  # 2 hours
+    )
+    token = await jwt_strategy.write_token(user)
+
+    return JSONResponse(
+        content={"access_token": token, "token_type": "bearer"},
+        status_code=200,
+    )

fractal_server/app/routes/admin/v2/job.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from pathlib import Path
 from typing import Optional
 
@@ -8,6 +7,7 @@ from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
+from pydantic.types import AwareDatetime
 from sqlmodel import select
 
 from fractal_server.app.db import AsyncSession
@@ -16,7 +16,6 @@ from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.models.v2 import ProjectV2
 from fractal_server.app.routes.auth import current_active_superuser
-from fractal_server.app.routes.aux import _raise_if_naive_datetime
 from fractal_server.app.routes.aux._job import _write_shutdown_file
 from fractal_server.app.routes.aux._runner import _check_shutdown_is_supported
 from fractal_server.app.runner.filenames import WORKFLOW_LOG_FILENAME
@@ -37,10 +36,10 @@ async def view_job(
     dataset_id: Optional[int] = None,
     workflow_id: Optional[int] = None,
     status: Optional[JobStatusTypeV2] = None,
-    start_timestamp_min: Optional[datetime] = None,
-    start_timestamp_max: Optional[datetime] = None,
-    end_timestamp_min: Optional[datetime] = None,
-    end_timestamp_max: Optional[datetime] = None,
+    start_timestamp_min: Optional[AwareDatetime] = None,
+    start_timestamp_max: Optional[AwareDatetime] = None,
+    end_timestamp_min: Optional[AwareDatetime] = None,
+    end_timestamp_max: Optional[AwareDatetime] = None,
     log: bool = True,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
@@ -67,13 +66,6 @@ async def view_job(
             `job.log` is set to `None`.
     """
 
-    _raise_if_naive_datetime(
-        start_timestamp_min,
-        start_timestamp_max,
-        end_timestamp_min,
-        end_timestamp_max,
-    )
-
     stm = select(JobV2)
 
     if id is not None:

fractal_server/app/routes/admin/v2/task.py

@@ -28,7 +28,7 @@ class TaskV2Minimal(BaseModel):
     type: str
     taskgroupv2_id: int
     command_non_parallel: Optional[str] = None
-    command_parallel: Optional[str]
+    command_parallel: Optional[str] = None
     source: Optional[str] = None
     version: Optional[str] = None
 

fractal_server/app/routes/admin/v2/task_group.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from typing import Optional
 
 from fastapi import APIRouter
@@ -6,6 +5,7 @@ from fastapi import Depends
 from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
+from pydantic.types import AwareDatetime
 from sqlalchemy.sql.operators import is_
 from sqlalchemy.sql.operators import is_not
 from sqlmodel import select
@@ -20,7 +20,6 @@ from fractal_server.app.routes.auth import current_active_superuser
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
-from fractal_server.app.routes.aux import _raise_if_naive_datetime
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
@@ -42,13 +41,11 @@ async def get_task_group_activity_list(
     pkg_name: Optional[str] = None,
     status: Optional[TaskGroupActivityStatusV2] = None,
     action: Optional[TaskGroupActivityActionV2] = None,
-    timestamp_started_min: Optional[datetime] = None,
+    timestamp_started_min: Optional[AwareDatetime] = None,
     superuser: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupActivityV2Read]:
 
-    _raise_if_naive_datetime(timestamp_started_min)
-
     stm = select(TaskGroupActivityV2)
     if task_group_activity_id is not None:
         stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
@@ -96,19 +93,14 @@ async def query_task_group_list(
     active: Optional[bool] = None,
     pkg_name: Optional[str] = None,
     origin: Optional[TaskGroupV2OriginEnum] = None,
-    timestamp_last_used_min: Optional[datetime] = None,
-    timestamp_last_used_max: Optional[datetime] = None,
+    timestamp_last_used_min: Optional[AwareDatetime] = None,
+    timestamp_last_used_max: Optional[AwareDatetime] = None,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupReadV2]:
 
     stm = select(TaskGroupV2)
 
-    _raise_if_naive_datetime(
-        timestamp_last_used_max,
-        timestamp_last_used_min,
-    )
-
     if user_group_id is not None and private is True:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
@@ -163,7 +155,7 @@ async def patch_task_group(
             detail=f"TaskGroupV2 {task_group_id} not found",
         )
 
-    for key, value in task_group_update.dict(exclude_unset=True).items():
+    for key, value in task_group_update.model_dump(exclude_unset=True).items():
         if (key == "user_group_id") and (value is not None):
             await _verify_user_belongs_to_group(
                 user_id=user.id, user_group_id=value, db=db

fractal_server/app/routes/api/v2/_aux_functions_task_lifecycle.py

@@ -55,7 +55,7 @@ async def get_package_version_from_pypi(
             f"A TimeoutException occurred while getting {url}.\n"
             f"Original error: {str(e)}."
         )
-        logger.error(error_msg)
+        logger.warning(error_msg)
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=error_msg,
@@ -65,7 +65,7 @@ async def get_package_version_from_pypi(
             f"An unknown error occurred while getting {url}. "
             f"Original error: {str(e)}."
         )
-        logger.error(error_msg)
+        logger.warning(error_msg)
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=error_msg,
@@ -85,7 +85,7 @@ async def get_package_version_from_pypi(
         latest_version = response_data["info"]["version"]
         available_releases = response_data["releases"].keys()
     except KeyError as e:
-        logger.error(
+        logger.warning(
             f"A KeyError occurred while getting {url}. "
             f"Original error: {str(e)}."
         )

fractal_server/app/routes/api/v2/dataset.py

@@ -60,7 +60,7 @@ async def create_dataset(
         db_dataset = DatasetV2(
             project_id=project_id,
             zarr_dir="__PLACEHOLDER__",
-            **dataset.dict(exclude={"zarr_dir"}),
+            **dataset.model_dump(exclude={"zarr_dir"}),
         )
         db.add(db_dataset)
         await db.commit()
@@ -77,7 +77,7 @@ async def create_dataset(
         await db.commit()
         await db.refresh(db_dataset)
     else:
-        db_dataset = DatasetV2(project_id=project_id, **dataset.dict())
+        db_dataset = DatasetV2(project_id=project_id, **dataset.model_dump())
         db.add(db_dataset)
         await db.commit()
         await db.refresh(db_dataset)
@@ -172,7 +172,7 @@ async def update_dataset(
             ),
         )
 
-    for key, value in dataset_update.dict(exclude_unset=True).items():
+    for key, value in dataset_update.model_dump(exclude_unset=True).items():
         setattr(db_dataset, key, value)
 
     await db.commit()
@@ -316,7 +316,7 @@ async def import_dataset(
     # Create new Dataset
     db_dataset = DatasetV2(
         project_id=project_id,
-        **dataset.dict(exclude_none=True),
+        **dataset.model_dump(exclude_none=True),
     )
     db.add(db_dataset)
     await db.commit()

fractal_server/app/routes/api/v2/images.py

@@ -8,8 +8,8 @@ from fastapi import Response
 from fastapi import status
 from pydantic import BaseModel
 from pydantic import Field
-from pydantic import root_validator
-from pydantic import validator
+from pydantic import field_validator
+from pydantic import model_validator
 from sqlalchemy.orm.attributes import flag_modified
 
 from ._aux_functions import _get_dataset_check_owner
@@ -44,18 +44,18 @@ class ImagePage(BaseModel):
 
 
 class ImageQuery(BaseModel):
-    zarr_url: Optional[str]
+    zarr_url: Optional[str] = None
     type_filters: dict[str, bool] = Field(default_factory=dict)
     attribute_filters: AttributeFiltersType = Field(default_factory=dict)
 
-    _dict_keys = root_validator(pre=True, allow_reuse=True)(
-        root_validate_dict_keys
+    _dict_keys = model_validator(mode="before")(
+        classmethod(root_validate_dict_keys)
     )
-    _type_filters = validator("type_filters", allow_reuse=True)(
-        validate_type_filters
+    _type_filters = field_validator("type_filters")(
+        classmethod(validate_type_filters)
     )
-    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
-        validate_attribute_filters
+    _attribute_filters = field_validator("attribute_filters")(
+        classmethod(validate_attribute_filters)
     )
 
 
@@ -102,7 +102,7 @@ async def post_new_image(
             ),
         )
 
-    dataset.images.append(new_image.dict())
+    dataset.images.append(new_image.model_dump())
     flag_modified(dataset, "images")
 
     await db.commit()
@@ -278,7 +278,7 @@ async def patch_dataset_image(
         )
     index = ret["index"]
 
-    for key, value in image_update.dict(
+    for key, value in image_update.model_dump(
         exclude_none=True, exclude={"zarr_url"}
     ).items():
         db_dataset.images[index][key] = value