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

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

@@ -11,12 +11,17 @@ from pydantic import Field
 from pydantic import field_validator
 from pydantic import model_validator
 from sqlalchemy.orm.attributes import flag_modified
+from sqlmodel import delete
 
 from ._aux_functions import _get_dataset_check_owner
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
+from fractal_server.app.models import HistoryImageCache
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_user
+from fractal_server.app.routes.pagination import get_pagination_params
+from fractal_server.app.routes.pagination import PaginationRequest
+from fractal_server.app.routes.pagination import PaginationResponse
 from fractal_server.app.schemas._filter_validators import (
     validate_attribute_filters,
 )
@@ -25,26 +30,21 @@ 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 aggregate_attributes
+from fractal_server.images.tools import aggregate_types
 from fractal_server.images.tools import find_image_by_zarr_url
 from fractal_server.images.tools import match_filter
 
 router = APIRouter()
 
 
-class ImagePage(BaseModel):
-
-    total_count: int
-    page_size: int
-    current_page: int
+class ImagePage(PaginationResponse[SingleImage]):
 
     attributes: dict[str, list[Any]]
     types: list[str]
 
-    images: list[SingleImage]
-
 
 class ImageQuery(BaseModel):
-    zarr_url: Optional[str] = None
     type_filters: dict[str, bool] = Field(default_factory=dict)
     attribute_filters: AttributeFiltersType = Field(default_factory=dict)
 
@@ -59,6 +59,10 @@ class ImageQuery(BaseModel):
     )
 
 
+class ImageQueryWithZarrUrl(ImageQuery):
+    zarr_url: Optional[str] = None
+
+
 @router.post(
     "/project/{project_id}/dataset/{dataset_id}/images/",
     status_code=status.HTTP_201_CREATED,
@@ -118,18 +122,14 @@ async def post_new_image(
 async def query_dataset_images(
     project_id: int,
     dataset_id: int,
-    page: int = 1,  # query param
-    page_size: Optional[int] = None,  # query param
-    query: Optional[ImageQuery] = None,  # body
+    query: Optional[ImageQueryWithZarrUrl] = None,
+    pagination: PaginationRequest = Depends(get_pagination_params),
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ) -> ImagePage:
 
-    if page < 1:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Invalid pagination parameter: page={page} < 1",
-        )
+    page = pagination.page
+    page_size = pagination.page_size
 
     output = await _get_dataset_check_owner(
         project_id=project_id, dataset_id=dataset_id, user_id=user.id, db=db
@@ -137,16 +137,8 @@ async def query_dataset_images(
     dataset = output["dataset"]
     images = dataset.images
 
-    attributes = {}
-    for image in images:
-        for k, v in image["attributes"].items():
-            attributes.setdefault(k, []).append(v)
-        for k, v in attributes.items():
-            attributes[k] = list(set(v))
-
-    types = list(
-        set(type for image in images for type in image["types"].keys())
-    )
+    attributes = aggregate_attributes(images)
+    types = aggregate_types(images)
 
     if query is not None:
 
@@ -177,20 +169,10 @@ async def query_dataset_images(
 
     total_count = len(images)
 
-    if page_size is not None:
-        if page_size <= 0:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=(
-                    f"Invalid pagination parameter: page_size={page_size} <= 0"
-                ),
-            )
-    else:
+    if page_size is None:
         page_size = total_count
 
-    if total_count == 0:
-        page = 1
-    else:
+    if total_count > 0:
         last_page = (total_count // page_size) + (total_count % page_size > 0)
         if page > last_page:
             page = last_page
@@ -201,9 +183,9 @@ async def query_dataset_images(
         total_count=total_count,
         current_page=page,
         page_size=page_size,
+        items=images,
         attributes=attributes,
         types=types,
-        images=images,
     )
 
 
@@ -224,10 +206,10 @@ async def delete_dataset_images(
     )
     dataset = output["dataset"]
 
-    image_to_remove = next(
-        (image for image in dataset.images if image["zarr_url"] == zarr_url),
-        None,
+    image_to_remove = find_image_by_zarr_url(
+        images=dataset.images, zarr_url=zarr_url
     )
+
     if image_to_remove is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -237,9 +219,15 @@ async def delete_dataset_images(
             ),
         )
 
-    dataset.images.remove(image_to_remove)
+    dataset.images.remove(image_to_remove["image"])
     flag_modified(dataset, "images")
 
+    await db.execute(
+        delete(HistoryImageCache)
+        .where(HistoryImageCache.dataset_id == dataset_id)
+        .where(HistoryImageCache.zarr_url == zarr_url)
+    )
+
     await db.commit()
 
     return Response(status_code=status.HTTP_204_NO_CONTENT)

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

@@ -5,6 +5,7 @@ from typing import Optional
 
 from fastapi import APIRouter
 from fastapi import Depends
+from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
@@ -83,6 +84,35 @@ async def get_workflow_jobs(
     return job_list
 
 
+@router.get("/project/{project_id}/latest-job/")
+async def get_latest_job(
+    project_id: int,
+    workflow_id: int,
+    dataset_id: int,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> JobReadV2:
+    await _get_workflow_check_owner(
+        project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
+    )
+    stm = (
+        select(JobV2)
+        .where(JobV2.project_id == project_id)
+        .where(JobV2.workflow_id == workflow_id)
+        .where(JobV2.dataset_id == dataset_id)
+        .order_by(JobV2.start_timestamp.desc())
+        .limit(1)
+    )
+    res = await db.execute(stm)
+    latest_job = res.scalar_one_or_none()
+    if latest_job is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Job with {workflow_id=} and {dataset_id=} not found.",
+        )
+    return latest_job
+
+
 @router.get(
     "/project/{project_id}/job/{job_id}/",
     response_model=JobReadV2,

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

@@ -11,11 +11,9 @@ from .....logger import reset_logger_handlers
 from .....logger import set_logger
 from ....db import AsyncSession
 from ....db import get_async_db
-from ....models.v2 import DatasetV2
 from ....models.v2 import JobV2
 from ....models.v2 import LinkUserProjectV2
 from ....models.v2 import ProjectV2
-from ....models.v2 import WorkflowV2
 from ....schemas.v2 import ProjectCreateV2
 from ....schemas.v2 import ProjectReadV2
 from ....schemas.v2 import ProjectUpdateV2
@@ -54,7 +52,7 @@ async def create_project(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[ProjectReadV2]:
     """
-    Create new poject
+    Create new project
     """
 
     # Check that there is no project with the same user and name
@@ -145,56 +143,6 @@ async def delete_project(
             ),
         )
 
-    # Cascade operations
-
-    # Workflows
-    stm = select(WorkflowV2).where(WorkflowV2.project_id == project_id)
-    res = await db.execute(stm)
-    workflows = res.scalars().all()
-    logger.info("Start of cascade operations on Workflows.")
-    for wf in workflows:
-        # Cascade operations: set foreign-keys to null for jobs which are in
-        # relationship with the current workflow
-        stm = select(JobV2).where(JobV2.workflow_id == wf.id)
-        res = await db.execute(stm)
-        jobs = res.scalars().all()
-        for job in jobs:
-            logger.info(f"Setting Job[{job.id}].workflow_id to None.")
-            job.workflow_id = None
-        # Delete workflow
-        logger.info(f"Adding Workflow[{wf.id}] to deletion.")
-        await db.delete(wf)
-    logger.info("End of cascade operations on Workflows.")
-
-    # Dataset
-    stm = select(DatasetV2).where(DatasetV2.project_id == project_id)
-    res = await db.execute(stm)
-    datasets = res.scalars().all()
-    logger.info("Start of cascade operations on Datasets.")
-    for ds in datasets:
-        # Cascade operations: set foreign-keys to null for jobs which are in
-        # relationship with the current dataset
-        stm = select(JobV2).where(JobV2.dataset_id == ds.id)
-        res = await db.execute(stm)
-        jobs = res.scalars().all()
-        for job in jobs:
-            logger.info(f"Setting Job[{job.id}].dataset_id to None.")
-            job.dataset_id = None
-        # Delete dataset
-        logger.info(f"Adding Dataset[{ds.id}] to deletion.")
-        await db.delete(ds)
-    logger.info("End of cascade operations on Datasets.")
-
-    # Job
-    logger.info("Start of cascade operations on Jobs.")
-    stm = select(JobV2).where(JobV2.project_id == project_id)
-    res = await db.execute(stm)
-    jobs = res.scalars().all()
-    for job in jobs:
-        logger.info(f"Setting Job[{job.id}].project_id to None.")
-        job.project_id = None
-    logger.info("End of cascade operations on Jobs.")
-
     logger.info(f"Adding Project[{project.id}] to deletion.")
     await db.delete(project)
 

fractal_server/app/routes/api/v2/{status.py → status_legacy.py}

@@ -9,8 +9,8 @@ from .....logger import set_logger
 from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import JobV2
-from ....schemas.v2.dataset import WorkflowTaskStatusTypeV2
-from ....schemas.v2.status import StatusReadV2
+from ....schemas.v2.status_legacy import LegacyStatusReadV2
+from ....schemas.v2.status_legacy import WorkflowTaskStatusTypeV2
 from ._aux_functions import _get_dataset_check_owner
 from ._aux_functions import _get_submitted_jobs_statement
 from ._aux_functions import _get_workflow_check_owner
@@ -23,8 +23,8 @@ logger = set_logger(__name__)
 
 
 @router.get(
-    "/project/{project_id}/status/",
-    response_model=StatusReadV2,
+    "/project/{project_id}/status-legacy/",
+    response_model=LegacyStatusReadV2,
 )
 async def get_workflowtask_status(
     project_id: int,
@@ -32,7 +32,7 @@ async def get_workflowtask_status(
     workflow_id: int,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[StatusReadV2]:
+) -> Optional[LegacyStatusReadV2]:
     """
     Extract the status of all `WorkflowTaskV2` of a given `WorkflowV2` that ran
     on a given `DatasetV2`.
@@ -164,5 +164,5 @@ async def get_workflowtask_status(
             # first time that you hit `last_valid_wftask_id``
             break
 
-    response_body = StatusReadV2(status=clean_workflow_tasks_status_dict)
+    response_body = LegacyStatusReadV2(status=clean_workflow_tasks_status_dict)
     return response_body

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

@@ -11,30 +11,32 @@ from fastapi import Request
 from fastapi import status
 from sqlmodel import select
 
-from .....config import get_settings
-from .....logger import set_logger
-from .....syringe import Inject
-from ....db import AsyncSession
-from ....db import get_async_db
-from ....models.v2 import JobV2
-from ....runner.set_start_and_last_task_index import (
-    set_start_and_last_task_index,
-)
-from ....runner.v2 import submit_workflow
-from ....schemas.v2 import JobCreateV2
-from ....schemas.v2 import JobReadV2
-from ....schemas.v2 import JobStatusTypeV2
-from ...aux.validate_user_settings import validate_user_settings
 from ._aux_functions import _get_dataset_check_owner
 from ._aux_functions import _get_workflow_check_owner
 from ._aux_functions import clean_app_job_list_v2
 from ._aux_functions_tasks import _check_type_filters_compatibility
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
 from fractal_server.app.models import TaskGroupV2
 from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_read_access,
 )
 from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.aux.validate_user_settings import (
+    validate_user_settings,
+)
+from fractal_server.app.runner.set_start_and_last_task_index import (
+    set_start_and_last_task_index,
+)
+from fractal_server.app.runner.v2.submit_workflow import submit_workflow
+from fractal_server.app.schemas.v2 import JobCreateV2
+from fractal_server.app.schemas.v2 import JobReadV2
+from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.config import get_settings
+from fractal_server.logger import set_logger
+from fractal_server.syringe import Inject
 
 
 router = APIRouter()

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

@@ -152,14 +152,7 @@ async def create_task(
         db=db,
     )
 
-    if task.command_non_parallel is None:
-        task_type = "parallel"
-    elif task.command_parallel is None:
-        task_type = "non_parallel"
-    else:
-        task_type = "compound"
-
-    if task_type == "parallel" and (
+    if task.type == "parallel" and (
         task.args_schema_non_parallel is not None
         or task.meta_non_parallel is not None
     ):
@@ -170,7 +163,7 @@ async def create_task(
                 "`TaskV2.args_schema_non_parallel` if TaskV2 is parallel"
             ),
         )
-    elif task_type == "non_parallel" and (
+    elif task.type == "non_parallel" and (
         task.args_schema_parallel is not None or task.meta_parallel is not None
     ):
         raise HTTPException(
@@ -183,7 +176,7 @@ async def create_task(
 
     # Add task
 
-    db_task = TaskV2(**task.model_dump(exclude_unset=True), type=task_type)
+    db_task = TaskV2(**task.model_dump(exclude_unset=True))
     pkg_name = db_task.name
     await _verify_non_duplication_user_constraint(
         db=db, pkg_name=pkg_name, user_id=user.id, version=db_task.version

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

@@ -12,9 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from ._aux_functions_tasks import _get_valid_user_group_id
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
 from ._aux_functions_tasks import _verify_non_duplication_user_constraint
-from fractal_server.app.db import DBSyncSession
 from fractal_server.app.db import get_async_db
-from fractal_server.app.db import get_sync_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.routes.auth import current_active_verified_user
@@ -31,7 +29,7 @@ from fractal_server.tasks.v2.utils_background import (
     _prepare_tasks_metadata,
 )
 from fractal_server.tasks.v2.utils_database import (
-    create_db_tasks_and_update_task_group,
+    create_db_tasks_and_update_task_group_async,
 )
 
 router = APIRouter()
@@ -47,10 +45,7 @@ async def collect_task_custom(
     private: bool = False,
     user_group_id: Optional[int] = None,
     user: UserOAuth = Depends(current_active_verified_user),
-    db: AsyncSession = Depends(get_async_db),  # FIXME: using both sync/async
-    db_sync: DBSyncSession = Depends(
-        get_sync_db
-    ),  # FIXME: using both sync/async
+    db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskReadV2]:
 
     settings = Inject(get_settings)
@@ -168,10 +163,10 @@ async def collect_task_custom(
     await db.refresh(task_group)
     db.expunge(task_group)
 
-    task_group = create_db_tasks_and_update_task_group(
+    task_group = await create_db_tasks_and_update_task_group_async(
         task_list=task_list,
         task_group_id=task_group.id,
-        db=db_sync,
+        db=db,
     )
 
     logger.debug(

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

@@ -181,23 +181,6 @@ async def delete_task_group(
             detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
         )
 
-    # Cascade operations: set foreign-keys to null for TaskGroupActivityV2
-    # which are in relationship with the current TaskGroupV2
-    logger.debug("Start of cascade operations on TaskGroupActivityV2.")
-    stm = select(TaskGroupActivityV2).where(
-        TaskGroupActivityV2.taskgroupv2_id == task_group_id
-    )
-    res = await db.execute(stm)
-    task_group_activity_list = res.scalars().all()
-    for task_group_activity in task_group_activity_list:
-        logger.debug(
-            f"Setting TaskGroupActivityV2[{task_group_activity.id}]"
-            ".taskgroupv2_id to None."
-        )
-        task_group_activity.taskgroupv2_id = None
-        db.add(task_group_activity)
-    logger.debug("End of cascade operations on TaskGroupActivityV2.")
-
     await db.delete(task_group)
     await db.commit()
 

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

@@ -0,0 +1,61 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import status
+
+from ._aux_functions import _get_dataset_check_owner
+from .images import ImageQuery
+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.tools import aggregate_types
+from fractal_server.images.tools import filter_image_list
+
+router = APIRouter()
+
+
+@router.post(
+    "/project/{project_id}/dataset/{dataset_id}/images/verify-unique-types/",
+    status_code=status.HTTP_200_OK,
+)
+async def verify_unique_types(
+    project_id: int,
+    dataset_id: int,
+    query: Optional[ImageQuery] = None,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[str]:
+    # Get dataset
+    output = await _get_dataset_check_owner(
+        project_id=project_id, dataset_id=dataset_id, user_id=user.id, db=db
+    )
+    dataset = output["dataset"]
+
+    # Filter images
+    if query is None:
+        filtered_images = dataset.images
+    else:
+        filtered_images = filter_image_list(
+            images=dataset.images,
+            attribute_filters=query.attribute_filters,
+            type_filters=query.type_filters,
+        )
+
+    # Get actual values for each available type
+    available_types = aggregate_types(filtered_images)
+    values_per_type: dict[str, set] = {
+        _type: set() for _type in available_types
+    }
+    for _img in filtered_images:
+        for _type in available_types:
+            values_per_type[_type].add(_img["types"].get(_type, False))
+
+    # Find types with non-unique value
+    non_unique_types = [
+        key for key, value in values_per_type.items() if len(value) > 1
+    ]
+    non_unique_types = sorted(non_unique_types)
+
+    return non_unique_types

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

@@ -14,16 +14,12 @@ from ....db import get_async_db
 from ....models.v2 import JobV2
 from ....models.v2 import ProjectV2
 from ....models.v2 import WorkflowV2
-from ....runner.set_start_and_last_task_index import (
-    set_start_and_last_task_index,
-)
 from ....schemas.v2 import WorkflowCreateV2
 from ....schemas.v2 import WorkflowExportV2
 from ....schemas.v2 import WorkflowReadV2
 from ....schemas.v2 import WorkflowReadV2WithWarnings
 from ....schemas.v2 import WorkflowUpdateV2
 from ._aux_functions import _check_workflow_exists
-from ._aux_functions import _get_dataset_check_owner
 from ._aux_functions import _get_project_check_owner
 from ._aux_functions import _get_submitted_jobs_statement
 from ._aux_functions import _get_workflow_check_owner
@@ -225,14 +221,6 @@ async def delete_workflow(
             ),
         )
 
-    # Cascade operations: set foreign-keys to null for jobs which are in
-    # relationship with the current workflow
-    stm = select(JobV2).where(JobV2.workflow_id == workflow_id)
-    res = await db.execute(stm)
-    jobs = res.scalars().all()
-    for job in jobs:
-        job.workflow_id = None
-
     # Delete workflow
     await db.delete(workflow)
     await db.commit()
@@ -244,7 +232,7 @@ async def delete_workflow(
     "/project/{project_id}/workflow/{workflow_id}/export/",
     response_model=WorkflowExportV2,
 )
-async def export_worfklow(
+async def export_workflow(
     project_id: int,
     workflow_id: int,
     user: UserOAuth = Depends(current_active_user),
@@ -293,27 +281,22 @@ async def get_user_workflows(
     return workflow_list
 
 
-class TypeFiltersFlow(BaseModel):
-    dataset_filters: list[dict[str, bool]]
-    input_filters: list[dict[str, bool]]
-    output_filters: list[dict[str, bool]]
+class WorkflowTaskTypeFiltersInfo(BaseModel):
+    workflowtask_id: int
+    current_type_filters: dict[str, bool]
+    input_type_filters: dict[str, bool]
+    output_type_filters: dict[str, bool]
 
 
-@router.get(
-    "/project/{project_id}/workflow/{workflow_id}/type-filters-flow/",
-    response_model=TypeFiltersFlow,
-)
+@router.get("/project/{project_id}/workflow/{workflow_id}/type-filters-flow/")
 async def get_workflow_type_filters(
     project_id: int,
     workflow_id: int,
-    dataset_id: Optional[int] = None,
-    first_task_index: Optional[int] = None,
-    last_task_index: Optional[int] = None,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
-) -> Optional[WorkflowReadV2WithWarnings]:
+) -> list[WorkflowTaskTypeFiltersInfo]:
     """
-    Get info on an existing workflow
+    Get info on type/type-filters flow for a workflow.
     """
 
     workflow = await _get_workflow_check_owner(
@@ -323,59 +306,35 @@ async def get_workflow_type_filters(
         db=db,
     )
 
-    if len(workflow.task_list) == 0:
+    num_tasks = len(workflow.task_list)
+    if num_tasks == 0:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Workflow has no tasks.",
         )
 
-    if dataset_id is None:
-        dataset_type_filters = {}
-    else:
-        res = await _get_dataset_check_owner(
-            project_id=project_id,
-            dataset_id=dataset_id,
-            user_id=user.id,
-            db=db,
-        )
-        dataset = res["dataset"]
-        dataset_type_filters = dataset.type_filters
+    current_type_filters = {}
 
-    num_tasks = len(workflow.task_list)
-    try:
-        first_task_index, last_task_index = set_start_and_last_task_index(
-            num_tasks,
-            first_task_index=first_task_index,
-            last_task_index=last_task_index,
-        )
-    except ValueError as e:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Invalid first/last task index.\nOriginal error: {str(e)}",
-        )
-
-    list_dataset_filters = [copy(dataset_type_filters)]
-    list_filters_in = []
-    list_filters_out = []
-    for wftask in workflow.task_list[first_task_index : last_task_index + 1]:
+    response_items = []
+    for wftask in workflow.task_list:
 
-        input_type_filters = copy(dataset_type_filters)
-        patch = merge_type_filters(
+        # Compute input_type_filters, based on wftask and task manifest
+        input_type_filters = merge_type_filters(
             wftask_type_filters=wftask.type_filters,
             task_input_types=wftask.task.input_types,
         )
-        input_type_filters.update(patch)
-        list_filters_in.append(copy(input_type_filters))
 
-        output_type_filters = wftask.task.output_types
-        list_filters_out.append(output_type_filters)
+        # Append current item to response list
+        response_items.append(
+            dict(
+                workflowtask_id=wftask.id,
+                current_type_filters=copy(current_type_filters),
+                input_type_filters=copy(input_type_filters),
+                output_type_filters=copy(wftask.task.output_types),
+            )
+        )
 
-        dataset_type_filters.update(wftask.task.output_types)
-        list_dataset_filters.append(copy(dataset_type_filters))
+        # Update `current_type_filters`
+        current_type_filters.update(wftask.task.output_types)
 
-    response_body = dict(
-        dataset_filters=list_dataset_filters,
-        input_filters=list_filters_in,
-        output_filters=list_filters_out,
-    )
-    return response_body
+    return response_items