fractal-server 2.11.0a0__py3-none-any.whl → 2.11.0a2__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.11.0a0"
+__VERSION__ = "2.11.0a2"

fractal_server/app/models/v2/dataset.py

@@ -11,6 +11,7 @@ from sqlmodel import Relationship
 from sqlmodel import SQLModel
 
 from ....utils import get_timestamp
+from fractal_server.images.models import AttributeFiltersType
 
 
 class DatasetV2(SQLModel, table=True):
@@ -41,12 +42,14 @@ class DatasetV2(SQLModel, table=True):
         sa_column=Column(JSON, server_default="[]", nullable=False)
     )
 
-    filters: dict[Literal["attributes", "types"], dict[str, Any]] = Field(
-        sa_column=Column(
-            JSON,
-            nullable=False,
-            server_default='{"attributes": {}, "types": {}}',
-        )
+    filters: Optional[
+        dict[Literal["attributes", "types"], dict[str, Any]]
+    ] = Field(sa_column=Column(JSON, nullable=True, server_default="null"))
+    type_filters: dict[str, bool] = Field(
+        sa_column=Column(JSON, nullable=False, server_default="{}")
+    )
+    attribute_filters: AttributeFiltersType = Field(
+        sa_column=Column(JSON, nullable=False, server_default="{}")
     )
 
     @property

fractal_server/app/models/v2/job.py

@@ -10,6 +10,7 @@ from sqlmodel import SQLModel
 
 from ....utils import get_timestamp
 from ...schemas.v2 import JobStatusTypeV2
+from fractal_server.images.models import AttributeFiltersType
 
 
 class JobV2(SQLModel, table=True):
@@ -49,3 +50,7 @@ class JobV2(SQLModel, table=True):
     )
     status: str = JobStatusTypeV2.SUBMITTED
     log: Optional[str] = None
+
+    attribute_filters: AttributeFiltersType = Field(
+        sa_column=Column(JSON, nullable=False, server_default="{}")
+    )

fractal_server/app/models/v2/workflowtask.py

@@ -25,14 +25,11 @@ class WorkflowTaskV2(SQLModel, table=True):
     args_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
     args_non_parallel: Optional[dict[str, Any]] = Field(sa_column=Column(JSON))
 
-    input_filters: dict[
-        Literal["attributes", "types"], dict[str, Any]
-    ] = Field(
-        sa_column=Column(
-            JSON,
-            nullable=False,
-            server_default='{"attributes": {}, "types": {}}',
-        )
+    input_filters: Optional[
+        dict[Literal["attributes", "types"], dict[str, Any]]
+    ] = Field(sa_column=Column(JSON, nullable=True, server_default="null"))
+    type_filters: dict[str, bool] = Field(
+        sa_column=Column(JSON, nullable=False, server_default="{}")
     )
 
     # Task

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

@@ -21,7 +21,6 @@ from ....models.v2 import TaskV2
 from ....models.v2 import WorkflowTaskV2
 from ....models.v2 import WorkflowV2
 from ....schemas.v2 import JobStatusTypeV2
-from fractal_server.images import Filters
 
 
 async def _get_project_check_owner(
@@ -336,7 +335,7 @@ async def _workflow_insert_task(
     meta_non_parallel: Optional[dict[str, Any]] = None,
     args_non_parallel: Optional[dict[str, Any]] = None,
     args_parallel: Optional[dict[str, Any]] = None,
-    input_filters: Optional[Filters] = None,
+    type_filters: Optional[dict[str, bool]] = None,
     db: AsyncSession,
 ) -> WorkflowTaskV2:
     """
@@ -350,7 +349,7 @@ async def _workflow_insert_task(
         meta_non_parallel:
         args_non_parallel:
         args_parallel:
-        input_filters:
+        type_filters:
         db:
     """
     db_workflow = await db.get(WorkflowV2, workflow_id)
@@ -376,12 +375,6 @@ async def _workflow_insert_task(
     if final_meta_non_parallel == {}:
         final_meta_non_parallel = None
 
-    # Prepare input_filters attribute
-    if input_filters is None:
-        input_filters_kwarg = {}
-    else:
-        input_filters_kwarg = dict(input_filters=input_filters)
-
     # Create DB entry
     wf_task = WorkflowTaskV2(
         task_type=task_type,
@@ -390,7 +383,7 @@ async def _workflow_insert_task(
         args_parallel=args_parallel,
         meta_parallel=final_meta_parallel,
         meta_non_parallel=final_meta_non_parallel,
-        **input_filters_kwarg,
+        type_filters=(type_filters or dict()),
     )
     db_workflow.task_list.append(wf_task)
     flag_modified(db_workflow, "task_list")

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

@@ -8,6 +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 sqlalchemy.orm.attributes import flag_modified
 
 from ._aux_functions import _get_dataset_check_owner
@@ -15,9 +17,14 @@ 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_user
-from fractal_server.images import Filters
+from fractal_server.app.schemas._filter_validators import (
+    validate_attribute_filters,
+)
+from fractal_server.app.schemas._filter_validators import validate_type_filters
+from fractal_server.app.schemas._validators import root_validate_dict_keys
 from fractal_server.images import SingleImage
 from fractal_server.images import SingleImageUpdate
+from fractal_server.images.models import AttributeFiltersType
 from fractal_server.images.tools import find_image_by_zarr_url
 from fractal_server.images.tools import match_filter
 
@@ -38,7 +45,18 @@ class ImagePage(BaseModel):
 
 class ImageQuery(BaseModel):
     zarr_url: Optional[str]
-    filters: Filters = Field(default_factory=Filters)
+    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
+    )
+    _type_filters = validator("type_filters", allow_reuse=True)(
+        validate_type_filters
+    )
+    _attribute_filters = validator("attribute_filters", allow_reuse=True)(
+        validate_attribute_filters
+    )
 
 
 @router.post(
@@ -124,7 +142,11 @@ async def query_dataset_images(
         images = [
             image
             for image in images
-            if match_filter(image, Filters(**dataset.filters))
+            if match_filter(
+                image=image,
+                type_filters=dataset.type_filters,
+                attribute_filters=dataset.attribute_filters,
+            )
         ]
 
     attributes = {}
@@ -154,13 +176,14 @@ async def query_dataset_images(
             else:
                 images = [image]
 
-        if query.filters.attributes or query.filters.types:
+        if query.attribute_filters or query.type_filters:
             images = [
                 image
                 for image in images
                 if match_filter(
-                    image,
-                    Filters(**query.filters.dict()),
+                    image=image,
+                    type_filters=query.type_filters,
+                    attribute_filters=query.attribute_filters,
                 )
             ]
 

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

@@ -159,7 +159,11 @@ async def apply_workflow(
         dataset_id=dataset_id,
         workflow_id=workflow_id,
         user_email=user.email,
-        dataset_dump=json.loads(dataset.json(exclude={"images", "history"})),
+        # The 'filters' field is not supported any more but still exists as a
+        # database column, therefore we manually exclude it from dumps.
+        dataset_dump=json.loads(
+            dataset.json(exclude={"images", "history", "filters"})
+        ),
         workflow_dump=json.loads(workflow.json(exclude={"task_list"})),
         project_dump=json.loads(project.json(exclude={"user_list"})),
         **job_create.dict(),

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

@@ -109,7 +109,7 @@ async def replace_workflowtask(
         task_type=task.type,
         task=task,
         # old-task values
-        input_filters=old_workflow_task.input_filters,
+        type_filters=old_workflow_task.type_filters,
         # possibly new values
         args_non_parallel=_args_non_parallel,
         args_parallel=_args_parallel,
@@ -183,7 +183,7 @@ async def create_workflowtask(
         meta_parallel=new_task.meta_parallel,
         args_non_parallel=new_task.args_non_parallel,
         args_parallel=new_task.args_parallel,
-        input_filters=new_task.input_filters,
+        type_filters=new_task.type_filters,
         db=db,
     )
 
@@ -274,7 +274,7 @@ async def update_workflowtask(
             if not actual_args:
                 actual_args = None
             setattr(db_wf_task, key, actual_args)
-        elif key in ["meta_parallel", "meta_non_parallel", "input_filters"]:
+        elif key in ["meta_parallel", "meta_non_parallel", "type_filters"]:
             setattr(db_wf_task, key, value)
         else:
             raise HTTPException(

fractal_server/app/runner/v2/__init__.py

@@ -327,6 +327,7 @@ async def submit_workflow(
             worker_init=worker_init,
             first_task_index=job.first_task_index,
             last_task_index=job.last_task_index,
+            job_attribute_filters=job.attribute_filters,
             **backend_specific_kwargs,
         )
 

fractal_server/app/runner/v2/_local/__init__.py

@@ -29,6 +29,7 @@ from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _local_submit_setup
 from .executor import FractalThreadPoolExecutor
+from fractal_server.images.models import AttributeFiltersType
 
 
 def _process_workflow(
@@ -39,6 +40,7 @@ def _process_workflow(
     workflow_dir_local: Path,
     first_task_index: int,
     last_task_index: int,
+    job_attribute_filters: AttributeFiltersType,
 ) -> None:
     """
     Run the workflow using a `FractalThreadPoolExecutor`.
@@ -54,6 +56,7 @@ def _process_workflow(
             workflow_dir_remote=workflow_dir_local,
             logger_name=logger_name,
             submit_setup_call=_local_submit_setup,
+            job_attribute_filters=job_attribute_filters,
         )
 
 
@@ -66,6 +69,7 @@ async def process_workflow(
     first_task_index: Optional[int] = None,
     last_task_index: Optional[int] = None,
     logger_name: str,
+    job_attribute_filters: AttributeFiltersType,
     # Slurm-specific
     user_cache_dir: Optional[str] = None,
     slurm_user: Optional[str] = None,
@@ -146,4 +150,5 @@ async def process_workflow(
         workflow_dir_local=workflow_dir_local,
         first_task_index=first_task_index,
         last_task_index=last_task_index,
+        job_attribute_filters=job_attribute_filters,
     )

fractal_server/app/runner/v2/_local_experimental/__init__.py

@@ -11,6 +11,7 @@ from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _local_submit_setup
 from .executor import FractalProcessPoolExecutor
+from fractal_server.images.models import AttributeFiltersType
 
 
 def _process_workflow(
@@ -21,6 +22,7 @@ def _process_workflow(
     workflow_dir_local: Path,
     first_task_index: int,
     last_task_index: int,
+    job_attribute_filters: AttributeFiltersType,
 ) -> None:
     """
     Run the workflow using a `FractalProcessPoolExecutor`.
@@ -39,6 +41,7 @@ def _process_workflow(
                 workflow_dir_remote=workflow_dir_local,
                 logger_name=logger_name,
                 submit_setup_call=_local_submit_setup,
+                job_attribute_filters=job_attribute_filters,
             )
         except BrokenProcessPool as e:
             raise JobExecutionError(
@@ -58,6 +61,7 @@ async def process_workflow(
     first_task_index: Optional[int] = None,
     last_task_index: Optional[int] = None,
     logger_name: str,
+    job_attribute_filters: AttributeFiltersType,
     # Slurm-specific
     user_cache_dir: Optional[str] = None,
     slurm_user: Optional[str] = None,
@@ -138,4 +142,5 @@ async def process_workflow(
         workflow_dir_local=workflow_dir_local,
         first_task_index=first_task_index,
         last_task_index=last_task_index,
+        job_attribute_filters=job_attribute_filters,
     )

fractal_server/app/runner/v2/_slurm_ssh/__init__.py

@@ -29,9 +29,9 @@ from ...executors.slurm.ssh.executor import FractalSlurmSSHExecutor
 from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _slurm_submit_setup
+from fractal_server.images.models import AttributeFiltersType
 from fractal_server.logger import set_logger
 
-
 logger = set_logger(__name__)
 
 
@@ -46,6 +46,7 @@ def _process_workflow(
     last_task_index: int,
     fractal_ssh: FractalSSH,
     worker_init: Optional[Union[str, list[str]]] = None,
+    job_attribute_filters: AttributeFiltersType,
 ) -> None:
     """
     Run the workflow using a `FractalSlurmSSHExecutor`.
@@ -86,6 +87,7 @@ def _process_workflow(
             workflow_dir_remote=workflow_dir_remote,
             logger_name=logger_name,
             submit_setup_call=_slurm_submit_setup,
+            job_attribute_filters=job_attribute_filters,
         )
 
 
@@ -98,12 +100,13 @@ async def process_workflow(
     first_task_index: Optional[int] = None,
     last_task_index: Optional[int] = None,
     logger_name: str,
-    # Not used
+    job_attribute_filters: AttributeFiltersType,
     fractal_ssh: FractalSSH,
+    worker_init: Optional[str] = None,
+    # Not used
     user_cache_dir: Optional[str] = None,
     slurm_user: Optional[str] = None,
     slurm_account: Optional[str] = None,
-    worker_init: Optional[str] = None,
 ) -> None:
     """
     Process workflow (SLURM backend public interface)
@@ -127,4 +130,5 @@ async def process_workflow(
         last_task_index=last_task_index,
         worker_init=worker_init,
         fractal_ssh=fractal_ssh,
+        job_attribute_filters=job_attribute_filters,
     )

fractal_server/app/runner/v2/_slurm_sudo/__init__.py

@@ -27,6 +27,7 @@ from ...executors.slurm.sudo.executor import FractalSlurmExecutor
 from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _slurm_submit_setup
+from fractal_server.images.models import AttributeFiltersType
 
 
 def _process_workflow(
@@ -42,6 +43,7 @@ def _process_workflow(
     slurm_account: Optional[str] = None,
     user_cache_dir: str,
     worker_init: Optional[Union[str, list[str]]] = None,
+    job_attribute_filters: AttributeFiltersType,
 ) -> None:
     """
     Run the workflow using a `FractalSlurmExecutor`.
@@ -79,6 +81,7 @@ def _process_workflow(
             workflow_dir_remote=workflow_dir_remote,
             logger_name=logger_name,
             submit_setup_call=_slurm_submit_setup,
+            job_attribute_filters=job_attribute_filters,
         )
 
 
@@ -91,6 +94,7 @@ async def process_workflow(
     first_task_index: Optional[int] = None,
     last_task_index: Optional[int] = None,
     logger_name: str,
+    job_attribute_filters: AttributeFiltersType,
     # Slurm-specific
     user_cache_dir: Optional[str] = None,
     slurm_user: Optional[str] = None,
@@ -120,4 +124,5 @@ async def process_workflow(
         slurm_user=slurm_user,
         slurm_account=slurm_account,
         worker_init=worker_init,
+        job_attribute_filters=job_attribute_filters,
     )

fractal_server/app/runner/v2/merge_outputs.py

@@ -1,38 +1,35 @@
-from copy import copy
-
 from fractal_server.app.runner.v2.deduplicate_list import deduplicate_list
 from fractal_server.app.runner.v2.task_interface import TaskOutput
 
 
 def merge_outputs(task_outputs: list[TaskOutput]) -> TaskOutput:
 
+    if len(task_outputs) == 0:
+        return TaskOutput()
+
     final_image_list_updates = []
     final_image_list_removals = []
-    last_new_filters = None
 
-    for ind, task_output in enumerate(task_outputs):
+    for task_output in task_outputs:
 
         final_image_list_updates.extend(task_output.image_list_updates)
         final_image_list_removals.extend(task_output.image_list_removals)
 
-        # Check that all filters are the same
-        current_new_filters = task_output.filters
-        if ind == 0:
-            last_new_filters = copy(current_new_filters)
-        if current_new_filters != last_new_filters:
-            raise ValueError(f"{current_new_filters=} but {last_new_filters=}")
-        last_new_filters = copy(current_new_filters)
+        # Check that all type_filters are the same
+        if task_output.type_filters != task_outputs[0].type_filters:
+            raise ValueError(
+                f"{task_output.type_filters=} "
+                f"but {task_outputs[0].type_filters=}"
+            )
 
+    # Note: the ordering of `image_list_removals` is not guaranteed
     final_image_list_updates = deduplicate_list(final_image_list_updates)
-
-    additional_args = {}
-    if last_new_filters is not None:
-        additional_args["filters"] = last_new_filters
+    final_image_list_removals = list(set(final_image_list_removals))
 
     final_output = TaskOutput(
         image_list_updates=final_image_list_updates,
         image_list_removals=final_image_list_removals,
-        **additional_args,
+        type_filters=task_outputs[0].type_filters,
     )
 
     return final_output

fractal_server/app/runner/v2/runner.py

@@ -8,7 +8,6 @@ from typing import Optional
 
 from sqlalchemy.orm.attributes import flag_modified
 
-from ....images import Filters
 from ....images import SingleImage
 from ....images.tools import filter_image_list
 from ....images.tools import find_image_by_zarr_url
@@ -24,9 +23,11 @@ from fractal_server.app.models.v2 import DatasetV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
 from fractal_server.app.schemas.v2.dataset import _DatasetHistoryItemV2
 from fractal_server.app.schemas.v2.workflowtask import WorkflowTaskStatusTypeV2
+from fractal_server.images.models import AttributeFiltersType
 
 
 def execute_tasks_v2(
+    *,
     wf_task_list: list[WorkflowTaskV2],
     dataset: DatasetV2,
     executor: ThreadPoolExecutor,
@@ -34,6 +35,7 @@ def execute_tasks_v2(
     workflow_dir_remote: Optional[Path] = None,
     logger_name: Optional[str] = None,
     submit_setup_call: Callable = no_op_submit_setup_call,
+    job_attribute_filters: AttributeFiltersType,
 ) -> None:
     logger = logging.getLogger(logger_name)
 
@@ -47,7 +49,7 @@ def execute_tasks_v2(
     # Initialize local dataset attributes
     zarr_dir = dataset.zarr_dir
     tmp_images = deepcopy(dataset.images)
-    tmp_filters = deepcopy(dataset.filters)
+    tmp_type_filters = deepcopy(dataset.type_filters)
 
     for wftask in wf_task_list:
         task = wftask.task
@@ -57,19 +59,20 @@ def execute_tasks_v2(
         # PRE TASK EXECUTION
 
         # Get filtered images
-        pre_filters = dict(
-            types=copy(tmp_filters["types"]),
-            attributes=copy(tmp_filters["attributes"]),
-        )
-        pre_filters["types"].update(wftask.input_filters["types"])
-        pre_filters["attributes"].update(wftask.input_filters["attributes"])
+        pre_type_filters = copy(tmp_type_filters)
+        pre_type_filters.update(wftask.type_filters)
         filtered_images = filter_image_list(
             images=tmp_images,
-            filters=Filters(**pre_filters),
+            type_filters=pre_type_filters,
+            attribute_filters=job_attribute_filters,
         )
         # Verify that filtered images comply with task input_types
         for image in filtered_images:
-            if not match_filter(image, Filters(types=task.input_types)):
+            if not match_filter(
+                image=image,
+                type_filters=task.input_types,
+                attribute_filters={},
+            ):
                 raise JobExecutionError(
                     "Invalid filtered image list\n"
                     f"Task input types: {task.input_types=}\n"
@@ -259,38 +262,30 @@ def execute_tasks_v2(
             else:
                 tmp_images.pop(img_search["index"])
 
-        # Update filters.attributes:
-        # current + (task_output: not really, in current examples..)
-        if current_task_output.filters is not None:
-            tmp_filters["attributes"].update(
-                current_task_output.filters.attributes
-            )
-
-        # Find manifest ouptut types
-        types_from_manifest = task.output_types
+        # Update type_filters
 
-        # Find task-output types
-        if current_task_output.filters is not None:
-            types_from_task = current_task_output.filters.types
-        else:
-            types_from_task = {}
+        # Assign the type filters based on different sources
+        # (task manifest and post-execution task output)
+        type_filters_from_task_manifest = task.output_types
+        type_filters_from_task_output = current_task_output.type_filters
 
         # Check that key sets are disjoint
-        set_types_from_manifest = set(types_from_manifest.keys())
-        set_types_from_task = set(types_from_task.keys())
-        if not set_types_from_manifest.isdisjoint(set_types_from_task):
-            overlap = set_types_from_manifest.intersection(set_types_from_task)
+        keys_from_manifest = set(type_filters_from_task_manifest.keys())
+        keys_from_task_output = set(type_filters_from_task_output.keys())
+        if not keys_from_manifest.isdisjoint(keys_from_task_output):
+            overlap = keys_from_manifest.intersection(keys_from_task_output)
             raise JobExecutionError(
                 "Some type filters are being set twice, "
                 f"for task '{task_name}'.\n"
-                f"Types from task output: {types_from_task}\n"
-                f"Types from task maniest: {types_from_manifest}\n"
+                f"Types from task output: {type_filters_from_task_output}\n"
+                "Types from task manifest: "
+                f"{type_filters_from_task_manifest}\n"
                 f"Overlapping keys: {overlap}"
             )
 
         # Update filters.types
-        tmp_filters["types"].update(types_from_manifest)
-        tmp_filters["types"].update(types_from_task)
+        tmp_type_filters.update(type_filters_from_task_manifest)
+        tmp_type_filters.update(type_filters_from_task_output)
 
         # Write current dataset attributes (history, images, filters) into the
         # database. They can be used (1) to retrieve the latest state
@@ -299,9 +294,13 @@ def execute_tasks_v2(
         with next(get_sync_db()) as db:
             db_dataset = db.get(DatasetV2, dataset.id)
             db_dataset.history[-1]["status"] = WorkflowTaskStatusTypeV2.DONE
-            db_dataset.filters = tmp_filters
+            db_dataset.type_filters = tmp_type_filters
             db_dataset.images = tmp_images
-            for attribute_name in ["filters", "history", "images"]:
+            for attribute_name in [
+                "type_filters",
+                "history",
+                "images",
+            ]:
                 flag_modified(db_dataset, attribute_name)
             db.merge(db_dataset)
             db.commit()

fractal_server/app/runner/v2/task_interface.py

@@ -1,22 +1,47 @@
 from typing import Any
+from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import Extra
 from pydantic import Field
+from pydantic import root_validator
 from pydantic import validator
 
 from ....images import SingleImageTaskOutput
-from fractal_server.images import Filters
+from fractal_server.app.schemas._filter_validators import validate_type_filters
+from fractal_server.app.schemas._validators import root_validate_dict_keys
 from fractal_server.urls import normalize_url
 
 
+class LegacyFilters(BaseModel, extra=Extra.forbid):
+    """
+    For fractal-server<2.11, task output could include both
+    `filters["attributes"]` and `filters["types"]`. In the new version
+    there is a single field, named `type_filters`.
+    The current schema is only used to convert old type filters into the
+    new form, but it will reject any attribute filters.
+    """
+
+    types: dict[str, bool] = Field(default_factory=dict)
+    _types = validator("types", allow_reuse=True)(validate_type_filters)
+
+
 class TaskOutput(BaseModel, extra=Extra.forbid):
 
     image_list_updates: list[SingleImageTaskOutput] = Field(
         default_factory=list
     )
     image_list_removals: list[str] = Field(default_factory=list)
-    filters: Filters = Field(default_factory=Filters)
+
+    filters: Optional[LegacyFilters] = None
+    type_filters: dict[str, bool] = Field(default_factory=dict)
+
+    _dict_keys = root_validator(pre=True, allow_reuse=True)(
+        root_validate_dict_keys
+    )
+    _type_filters = validator("type_filters", allow_reuse=True)(
+        validate_type_filters
+    )
 
     def check_zarr_urls_are_unique(self) -> None:
         zarr_urls = [img.zarr_url for img in self.image_list_updates]
@@ -37,6 +62,20 @@ class TaskOutput(BaseModel, extra=Extra.forbid):
                 msg = f"{msg}\n{duplicate}"
             raise ValueError(msg)
 
+    @root_validator()
+    def update_legacy_filters(cls, values):
+        if values["filters"] is not None:
+            if values["type_filters"] != {}:
+                raise ValueError(
+                    "Cannot set both (legacy) 'filters' and 'type_filters'."
+                )
+            else:
+                # Convert legacy filters.types into new type_filters
+                values["type_filters"] = values["filters"].types
+                values["filters"] = None
+
+        return values
+
     @validator("image_list_removals")
     def normalize_paths(cls, v: list[str]) -> list[str]:
         return [normalize_url(zarr_url) for zarr_url in v]