fractal-server 2.14.0a2__py3-none-any.whl → 2.14.0a4__py3-none-any.whl

fractal_server/app/runner/v2/runner.py

@@ -1,4 +1,3 @@
-import json
 import logging
 from copy import copy
 from copy import deepcopy
@@ -7,6 +6,7 @@ from typing import Callable
 from typing import Optional
 
 from sqlalchemy.orm.attributes import flag_modified
+from sqlmodel import update
 
 from ....images import SingleImage
 from ....images.tools import filter_image_list
@@ -18,11 +18,10 @@ from .runner_functions import run_v2_task_non_parallel
 from .runner_functions import run_v2_task_parallel
 from .task_interface import TaskOutput
 from fractal_server.app.db import get_sync_db
-from fractal_server.app.history.status_enum import HistoryItemImageStatus
+from fractal_server.app.history.status_enum import XXXStatus
 from fractal_server.app.models.v2 import AccountingRecord
 from fractal_server.app.models.v2 import DatasetV2
-from fractal_server.app.models.v2 import HistoryItemV2
-from fractal_server.app.models.v2 import ImageStatus
+from fractal_server.app.models.v2 import HistoryRun
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
 from fractal_server.app.runner.executors.base_runner import BaseRunner
@@ -87,6 +86,7 @@ def execute_tasks_v2(
                 **wftask.model_dump(exclude={"task"}),
                 task=wftask.task.model_dump(),
             )
+
             # Exclude timestamps since they'd need to be serialized properly
             task_group = db.get(TaskGroupV2, wftask.task.taskgroupv2_id)
             task_group_dump = task_group.model_dump(
@@ -95,44 +95,18 @@ def execute_tasks_v2(
                     "timestamp_last_used",
                 }
             )
-            parameters_hash = str(
-                hash(
-                    json.dumps(
-                        [workflowtask_dump, task_group_dump],
-                        sort_keys=True,
-                        indent=None,
-                    ).encode("utf-8")
-                )
-            )
-            images = {
-                image["zarr_url"]: HistoryItemImageStatus.SUBMITTED
-                for image in filtered_images
-            }
-            history_item = HistoryItemV2(
+            history_run = HistoryRun(
                 dataset_id=dataset.id,
                 workflowtask_id=wftask.id,
                 workflowtask_dump=workflowtask_dump,
                 task_group_dump=task_group_dump,
-                parameters_hash=parameters_hash,
                 num_available_images=len(type_filtered_images),
-                num_current_images=len(filtered_images),
-                images=images,
+                status=XXXStatus.SUBMITTED,
             )
-            db.add(history_item)
-            for image in filtered_images:
-                db.merge(
-                    ImageStatus(
-                        zarr_url=image["zarr_url"],
-                        workflowtask_id=wftask.id,
-                        dataset_id=dataset.id,
-                        parameters_hash=parameters_hash,
-                        status=HistoryItemImageStatus.SUBMITTED,
-                        logfile="/placeholder",
-                    )
-                )
+            db.add(history_run)
             db.commit()
-            db.refresh(history_item)
-            history_item_id = history_item.id
+            db.refresh(history_run)
+            history_run_id = history_run.id
 
         # TASK EXECUTION (V2)
         if task.type == "non_parallel":
@@ -149,7 +123,8 @@ def execute_tasks_v2(
                 workflow_dir_remote=workflow_dir_remote,
                 executor=runner,
                 submit_setup_call=submit_setup_call,
-                history_item_id=history_item_id,
+                history_run_id=history_run_id,
+                dataset_id=dataset.id,
             )
         elif task.type == "parallel":
             current_task_output, num_tasks, exceptions = run_v2_task_parallel(
@@ -160,7 +135,8 @@ def execute_tasks_v2(
                 workflow_dir_remote=workflow_dir_remote,
                 executor=runner,
                 submit_setup_call=submit_setup_call,
-                history_item_id=history_item_id,
+                history_run_id=history_run_id,
+                dataset_id=dataset.id,
             )
         elif task.type == "compound":
             current_task_output, num_tasks, exceptions = run_v2_task_compound(
@@ -172,7 +148,8 @@ def execute_tasks_v2(
                 workflow_dir_remote=workflow_dir_remote,
                 executor=runner,
                 submit_setup_call=submit_setup_call,
-                history_item_id=history_item_id,
+                history_run_id=history_run_id,
+                dataset_id=dataset.id,
             )
         else:
             raise ValueError(f"Unexpected error: Invalid {task.type=}.")
@@ -198,7 +175,8 @@ def execute_tasks_v2(
         # Update image list
         num_new_images = 0
         current_task_output.check_zarr_urls_are_unique()
-        # FIXME: Introduce for loop over task outputs, and processe them sequentially
+        # FIXME: Introduce for loop over task outputs, and processe them
+        # sequentially
         # each failure should lead to an update of the specific image status
         for image_obj in current_task_output.image_list_updates:
             image = image_obj.model_dump()
@@ -319,22 +297,17 @@ def execute_tasks_v2(
         type_filters_from_task_manifest = task.output_types
         current_dataset_type_filters.update(type_filters_from_task_manifest)
 
-        # Write current dataset attributes (history, images, filters) into the
-        # database. They can be used (1) to retrieve the latest state
-        # when the job fails, (2) from within endpoints that need up-to-date
-        # information
         with next(get_sync_db()) as db:
+            # Write current dataset attributes (history + filters) into the
+            # database.
             db_dataset = db.get(DatasetV2, dataset.id)
             db_dataset.type_filters = current_dataset_type_filters
             db_dataset.images = tmp_images
-            for attribute_name in [
-                "type_filters",
-                "history",
-                "images",
-            ]:
+            for attribute_name in ["type_filters", "images"]:
                 flag_modified(db_dataset, attribute_name)
             db.merge(db_dataset)
             db.commit()
+            db.close()  # FIXME: why is this needed?
 
             # Create accounting record
             record = AccountingRecord(
@@ -345,15 +318,30 @@ def execute_tasks_v2(
             db.add(record)
             db.commit()
 
-        if exceptions != {}:
-            logger.error(
-                f'END    {wftask.order}-th task (name="{task_name}") '
-                "- ERROR."
-            )
-            # Raise first error
-            for key, value in exceptions.items():
-                raise JobExecutionError(
-                    info=(f"An error occurred.\nOriginal error:\n{value}")
+            # Update History tables, and raise an error if task failed
+            if exceptions == {}:
+                db.execute(
+                    update(HistoryRun)
+                    .where(HistoryRun.id == history_run_id)
+                    .values(status=XXXStatus.DONE)
+                )
+                db.commit()
+            else:
+                db.execute(
+                    update(HistoryRun)
+                    .where(HistoryRun.id == history_run_id)
+                    .values(status=XXXStatus.FAILED)
+                )
+                db.commit()
+                logger.error(
+                    f'END    {wftask.order}-th task (name="{task_name}") - '
+                    "ERROR."
+                )
+                # Raise first error
+                for key, value in exceptions.items():
+                    raise JobExecutionError(
+                        info=(f"An error occurred.\nOriginal error:\n{value}")
+                    )
+                logger.debug(
+                    f'END    {wftask.order}-th task (name="{task_name}")'
                 )
-
-        logger.debug(f'END    {wftask.order}-th task (name="{task_name}")')

fractal_server/app/runner/v2/runner_functions.py

@@ -1,13 +1,12 @@
 import functools
 import logging
-import traceback
 from pathlib import Path
 from typing import Any
-from typing import Callable
 from typing import Literal
 from typing import Optional
 
 from pydantic import ValidationError
+from sqlmodel import update
 
 from ..exceptions import JobExecutionError
 from .deduplicate_list import deduplicate_list
@@ -15,6 +14,10 @@ from .merge_outputs import merge_outputs
 from .runner_functions_low_level import run_single_task
 from .task_interface import InitTaskOutput
 from .task_interface import TaskOutput
+from fractal_server.app.db import get_sync_db
+from fractal_server.app.history.status_enum import XXXStatus
+from fractal_server.app.models.v2 import HistoryImageCache
+from fractal_server.app.models.v2 import HistoryUnit
 from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
 from fractal_server.app.runner.components import _COMPONENT_KEY_
@@ -59,38 +62,18 @@ def _cast_and_validate_InitTaskOutput(
         )
 
 
-def no_op_submit_setup_call(*args, **kwargs) -> dict:
+def no_op_submit_setup_call(
+    *,
+    wftask: WorkflowTaskV2,
+    root_dir_local: Path,
+    which_type: Literal["non_parallel", "parallel"],
+) -> dict[str, Any]:
     """
     Default (no-operation) interface of submit_setup_call in V2.
     """
     return {}
 
 
-# Backend-specific configuration
-def _get_executor_options(
-    *,
-    wftask: WorkflowTaskV2,
-    workflow_dir_local: Path,
-    workflow_dir_remote: Path,
-    submit_setup_call: Callable,
-    which_type: Literal["non_parallel", "parallel"],
-) -> dict:
-    try:
-        options = submit_setup_call(
-            wftask=wftask,
-            root_dir_local=workflow_dir_local,
-            root_dir_remote=workflow_dir_remote,
-            which_type=which_type,
-        )
-    except Exception as e:
-        tb = "".join(traceback.format_tb(e.__traceback__))
-        raise RuntimeError(
-            f"{type(e)} error in {submit_setup_call=}\n"
-            f"Original traceback:\n{tb}"
-        )
-    return options
-
-
 def _check_parallelization_list_size(my_list):
     if len(my_list) > MAX_PARALLELIZATION_LIST_SIZE:
         raise JobExecutionError(
@@ -109,8 +92,9 @@ def run_v2_task_non_parallel(
     workflow_dir_local: Path,
     workflow_dir_remote: Optional[Path] = None,
     executor: BaseRunner,
-    submit_setup_call: Callable = no_op_submit_setup_call,
-    history_item_id: int,
+    submit_setup_call: callable = no_op_submit_setup_call,
+    dataset_id: int,
+    history_run_id: int,
 ) -> tuple[TaskOutput, int, dict[int, BaseException]]:
     """
     This runs server-side (see `executor` argument)
@@ -123,11 +107,10 @@ def run_v2_task_non_parallel(
         )
         workflow_dir_remote = workflow_dir_local
 
-    executor_options = _get_executor_options(
+    executor_options = submit_setup_call(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
-        submit_setup_call=submit_setup_call,
+        root_dir_local=workflow_dir_local,
+        root_dir_remote=workflow_dir_remote,
         which_type="non_parallel",
     )
 
@@ -138,6 +121,29 @@ def run_v2_task_non_parallel(
     )
     function_kwargs[_COMPONENT_KEY_] = _index_to_component(0)
 
+    # Database History operations
+    with next(get_sync_db()) as db:
+        history_unit = HistoryUnit(
+            history_run_id=history_run_id,
+            status=XXXStatus.SUBMITTED,
+            logfile=None,  # FIXME
+            zarr_urls=function_kwargs["zarr_urls"],
+        )
+        db.add(history_unit)
+        db.commit()
+        db.refresh(history_unit)
+        history_unit_id = history_unit.id
+        for zarr_url in function_kwargs["zarr_urls"]:
+            db.merge(
+                HistoryImageCache(
+                    workflowtask_id=wftask.id,
+                    dataset_id=dataset_id,
+                    zarr_url=zarr_url,
+                    latest_history_unit_id=history_unit_id,
+                )
+            )
+        db.commit()
+
     result, exception = executor.submit(
         functools.partial(
             run_single_task,
@@ -147,18 +153,30 @@ def run_v2_task_non_parallel(
             root_dir_remote=workflow_dir_remote,
         ),
         parameters=function_kwargs,
-        history_item_id=history_item_id,
         **executor_options,
     )
 
     num_tasks = 1
-    if exception is None:
-        if result is None:
-            return (TaskOutput(), num_tasks, {})
+    with next(get_sync_db()) as db:
+        if exception is None:
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.DONE)
+            )
+            db.commit()
+            if result is None:
+                return (TaskOutput(), num_tasks, {})
+            else:
+                return (_cast_and_validate_TaskOutput(result), num_tasks, {})
         else:
-            return (_cast_and_validate_TaskOutput(result), num_tasks, {})
-    else:
-        return (TaskOutput(), num_tasks, {0: exception})
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.FAILED)
+            )
+            db.commit()
+            return (TaskOutput(), num_tasks, {0: exception})
 
 
 def run_v2_task_parallel(
@@ -169,32 +187,57 @@ def run_v2_task_parallel(
     executor: BaseRunner,
     workflow_dir_local: Path,
     workflow_dir_remote: Optional[Path] = None,
-    submit_setup_call: Callable = no_op_submit_setup_call,
-    history_item_id: int,
+    submit_setup_call: callable = no_op_submit_setup_call,
+    dataset_id: int,
+    history_run_id: int,
 ) -> tuple[TaskOutput, int, dict[int, BaseException]]:
 
     if len(images) == 0:
+        # FIXME: Do something with history units/images?
         return (TaskOutput(), 0, {})
 
     _check_parallelization_list_size(images)
 
-    executor_options = _get_executor_options(
+    executor_options = submit_setup_call(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
-        submit_setup_call=submit_setup_call,
+        root_dir_local=workflow_dir_local,
+        root_dir_remote=workflow_dir_remote,
         which_type="parallel",
     )
 
     list_function_kwargs = []
-    for ind, image in enumerate(images):
-        list_function_kwargs.append(
-            dict(
-                zarr_url=image["zarr_url"],
-                **(wftask.args_parallel or {}),
-            ),
-        )
-        list_function_kwargs[-1][_COMPONENT_KEY_] = _index_to_component(ind)
+    history_unit_ids = []
+    with next(get_sync_db()) as db:
+        for ind, image in enumerate(images):
+            list_function_kwargs.append(
+                dict(
+                    zarr_url=image["zarr_url"],
+                    **(wftask.args_parallel or {}),
+                ),
+            )
+            list_function_kwargs[-1][_COMPONENT_KEY_] = _index_to_component(
+                ind
+            )
+            history_unit = HistoryUnit(
+                history_run_id=history_run_id,
+                status=XXXStatus.SUBMITTED,
+                logfile=None,  # FIXME
+                zarr_urls=[image["zarr_url"]],
+            )
+            # FIXME: this should be a bulk operation
+            db.add(history_unit)
+            db.commit()
+            db.refresh(history_unit)
+            db.merge(
+                HistoryImageCache(
+                    workflowtask_id=wftask.id,
+                    dataset_id=dataset_id,
+                    zarr_url=image["zarr_url"],
+                    latest_history_unit_id=history_unit.id,
+                )
+            )
+            db.commit()
+            history_unit_ids.append(history_unit.id)
 
     results, exceptions = executor.multisubmit(
         functools.partial(
@@ -205,11 +248,12 @@ def run_v2_task_parallel(
             root_dir_remote=workflow_dir_remote,
         ),
         list_parameters=list_function_kwargs,
-        history_item_id=history_item_id,
         **executor_options,
     )
 
     outputs = []
+    history_unit_ids_done: list[int] = []
+    history_unit_ids_failed: list[int] = []
     for ind in range(len(list_function_kwargs)):
         if ind in results.keys():
             result = results[ind]
@@ -218,11 +262,26 @@ def run_v2_task_parallel(
             else:
                 output = _cast_and_validate_TaskOutput(result)
             outputs.append(output)
+            history_unit_ids_done.append(history_unit_ids[ind])
         elif ind in exceptions.keys():
             print(f"Bad: {exceptions[ind]}")
+            history_unit_ids_failed.append(history_unit_ids[ind])
         else:
             print("VERY BAD - should have not reached this point")
 
+    with next(get_sync_db()) as db:
+        db.execute(
+            update(HistoryUnit)
+            .where(HistoryUnit.id.in_(history_unit_ids_done))
+            .values(status=XXXStatus.DONE)
+        )
+        db.execute(
+            update(HistoryUnit)
+            .where(HistoryUnit.id.in_(history_unit_ids_failed))
+            .values(status=XXXStatus.FAILED)
+        )
+        db.commit()
+
     num_tasks = len(images)
     merged_output = merge_outputs(outputs)
     return (merged_output, num_tasks, exceptions)
@@ -237,22 +296,21 @@ def run_v2_task_compound(
     executor: BaseRunner,
     workflow_dir_local: Path,
     workflow_dir_remote: Optional[Path] = None,
-    submit_setup_call: Callable = no_op_submit_setup_call,
-    history_item_id: int,
+    submit_setup_call: callable = no_op_submit_setup_call,
+    dataset_id: int,
+    history_run_id: int,
 ) -> tuple[TaskOutput, int, dict[int, BaseException]]:
 
-    executor_options_init = _get_executor_options(
+    executor_options_init = submit_setup_call(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
-        submit_setup_call=submit_setup_call,
+        root_dir_local=workflow_dir_local,
+        root_dir_remote=workflow_dir_remote,
         which_type="non_parallel",
     )
-    executor_options_compute = _get_executor_options(
+    executor_options_compute = submit_setup_call(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
-        submit_setup_call=submit_setup_call,
+        root_dir_local=workflow_dir_local,
+        root_dir_remote=workflow_dir_remote,
         which_type="parallel",
     )
 
@@ -263,6 +321,33 @@ def run_v2_task_compound(
         **(wftask.args_non_parallel or {}),
     )
     function_kwargs[_COMPONENT_KEY_] = f"init_{_index_to_component(0)}"
+
+    # Create database History entries
+    input_image_zarr_urls = function_kwargs["zarr_urls"]
+    with next(get_sync_db()) as db:
+        # Create a single `HistoryUnit` for the whole compound task
+        history_unit = HistoryUnit(
+            history_run_id=history_run_id,
+            status=XXXStatus.SUBMITTED,
+            logfile=None,  # FIXME
+            zarr_urls=input_image_zarr_urls,
+        )
+        db.add(history_unit)
+        db.commit()
+        db.refresh(history_unit)
+        history_unit_id = history_unit.id
+        # Create one `HistoryImageCache` for each input image
+        for zarr_url in input_image_zarr_urls:
+            db.merge(
+                HistoryImageCache(
+                    workflowtask_id=wftask.id,
+                    dataset_id=dataset_id,
+                    zarr_url=zarr_url,
+                    latest_history_unit_id=history_unit_id,
+                )
+            )
+        db.commit()
+
     result, exception = executor.submit(
         functools.partial(
             run_single_task,
@@ -272,8 +357,6 @@ def run_v2_task_compound(
             root_dir_remote=workflow_dir_remote,
         ),
         parameters=function_kwargs,
-        history_item_id=history_item_id,
-        in_compound_task=True,
         **executor_options_init,
     )
 
@@ -284,6 +367,13 @@ def run_v2_task_compound(
         else:
             init_task_output = _cast_and_validate_InitTaskOutput(result)
     else:
+        with next(get_sync_db()) as db:
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.FAILED)
+            )
+            db.commit()
         return (TaskOutput(), num_tasks, {0: exception})
 
     parallelization_list = init_task_output.parallelization_list
@@ -295,6 +385,13 @@ def run_v2_task_compound(
     _check_parallelization_list_size(parallelization_list)
 
     if len(parallelization_list) == 0:
+        with next(get_sync_db()) as db:
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.DONE)
+            )
+            db.commit()
         return (TaskOutput(), 0, {})
 
     list_function_kwargs = []
@@ -319,12 +416,12 @@ def run_v2_task_compound(
             root_dir_remote=workflow_dir_remote,
         ),
         list_parameters=list_function_kwargs,
-        history_item_id=history_item_id,
         in_compound_task=True,
         **executor_options_compute,
     )
 
     outputs = []
+    failure = False
     for ind in range(len(list_function_kwargs)):
         if ind in results.keys():
             result = results[ind]
@@ -333,8 +430,27 @@ def run_v2_task_compound(
             else:
                 output = _cast_and_validate_TaskOutput(result)
             outputs.append(output)
+
         elif ind in exceptions.keys():
             print(f"Bad: {exceptions[ind]}")
+            failure = True
+        else:
+            print("VERY BAD - should have not reached this point")
+
+    with next(get_sync_db()) as db:
+        if failure:
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.FAILED)
+            )
+        else:
+            db.execute(
+                update(HistoryUnit)
+                .where(HistoryUnit.id == history_unit_id)
+                .values(status=XXXStatus.DONE)
+            )
+        db.commit()
 
     merged_output = merge_outputs(outputs)
     return (merged_output, num_tasks, exceptions)

fractal_server/app/schemas/_validators.py

@@ -1,43 +1,32 @@
 import os
+from typing import Annotated
 from typing import Any
 from typing import Optional
 
+from pydantic.types import StringConstraints
 
-def valstr(attribute: str, accept_none: bool = False):
-    """
-    Check that a string attribute is not an empty string, and remove the
-    leading and trailing whitespace characters.
 
-    If `accept_none`, the validator also accepts `None`.
-    """
+def cant_set_none(value: Any) -> Any:
+    if value is None:
+        raise ValueError("Field cannot be set to 'None'.")
+    return value
 
-    def val(cls, string: Optional[str]) -> Optional[str]:
-        if string is None:
-            if accept_none:
-                return string
-            else:
-                raise ValueError(
-                    f"String attribute '{attribute}' cannot be None"
-                )
-        s = string.strip()
-        if not s:
-            raise ValueError(f"String attribute '{attribute}' cannot be empty")
-        return s
 
-    return val
+NonEmptyString = Annotated[
+    str, StringConstraints(min_length=1, strip_whitespace=True)
+]
 
 
 def valdict_keys(attribute: str):
     def val(cls, d: Optional[dict[str, Any]]) -> Optional[dict[str, Any]]:
         """
-        Apply valstr to every key of the dictionary, and fail if there are
-        identical keys.
+        Strip every key of the dictionary, and fail if there are identical keys
         """
         if d is not None:
             old_keys = list(d.keys())
-            new_keys = [
-                valstr(f"{attribute}[{key}]")(cls, key) for key in old_keys
-            ]
+            new_keys = [key.strip() for key in old_keys]
+            if any(k == "" for k in new_keys):
+                raise ValueError(f"Empty string in {new_keys}.")
             if len(new_keys) != len(set(new_keys)):
                 raise ValueError(
                     f"Dictionary contains multiple identical keys: '{d}'."