fractal-server 2.14.0a3__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=None,
-                    )
-                )
+            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=}.")
@@ -320,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(
@@ -346,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

@@ -6,6 +6,7 @@ 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
@@ -13,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_
@@ -88,7 +93,8 @@ def run_v2_task_non_parallel(
     workflow_dir_remote: Optional[Path] = None,
     executor: BaseRunner,
     submit_setup_call: callable = no_op_submit_setup_call,
-    history_item_id: int,
+    dataset_id: int,
+    history_run_id: int,
 ) -> tuple[TaskOutput, int, dict[int, BaseException]]:
     """
     This runs server-side (see `executor` argument)
@@ -115,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,
@@ -124,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(
@@ -147,10 +188,12 @@ def run_v2_task_parallel(
     workflow_dir_local: Path,
     workflow_dir_remote: Optional[Path] = None,
     submit_setup_call: callable = no_op_submit_setup_call,
-    history_item_id: int,
+    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)
@@ -163,14 +206,38 @@ def run_v2_task_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(
@@ -181,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]
@@ -194,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)
@@ -214,7 +297,8 @@ def run_v2_task_compound(
     workflow_dir_local: Path,
     workflow_dir_remote: Optional[Path] = None,
     submit_setup_call: callable = no_op_submit_setup_call,
-    history_item_id: int,
+    dataset_id: int,
+    history_run_id: int,
 ) -> tuple[TaskOutput, int, dict[int, BaseException]]:
 
     executor_options_init = submit_setup_call(
@@ -237,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,
@@ -246,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,
     )
 
@@ -258,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
@@ -269,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 = []
@@ -293,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]
@@ -307,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}'."

fractal_server/app/schemas/user.py

@@ -7,8 +7,8 @@ from pydantic import Field
 from pydantic import field_validator
 from pydantic import ValidationInfo
 
+from ._validators import NonEmptyString
 from ._validators import val_unique_list
-from ._validators import valstr
 
 __all__ = (
     "UserRead",
@@ -57,12 +57,12 @@ class UserUpdate(schemas.BaseUserUpdate):
 
     model_config = ConfigDict(extra="forbid")
 
-    username: Optional[str] = None
+    username: Optional[NonEmptyString] = None
 
     # Validators
-    _username = field_validator("username")(classmethod(valstr("username")))
 
     @field_validator(
+        "username",
         "is_active",
         "is_verified",
         "is_superuser",
@@ -94,11 +94,14 @@ class UserCreate(schemas.BaseUserCreate):
         username:
     """
 
-    username: Optional[str] = None
+    username: Optional[NonEmptyString] = None
 
-    # Validators
-
-    _username = field_validator("username")(classmethod(valstr("username")))
+    @field_validator("username")
+    @classmethod
+    def cant_set_none(cls, v, info: ValidationInfo):
+        if v is None:
+            raise ValueError(f"Cannot set {info.field_name}=None")
+        return v
 
 
 class UserUpdateGroups(BaseModel):

fractal_server/app/schemas/user_settings.py

@@ -5,9 +5,9 @@ from pydantic import ConfigDict
 from pydantic import field_validator
 from pydantic.types import StrictStr
 
+from ._validators import NonEmptyString
 from ._validators import val_absolute_path
 from ._validators import val_unique_list
-from ._validators import valstr
 from fractal_server.string_tools import validate_cmd
 
 __all__ = (
@@ -48,21 +48,15 @@ class UserSettingsUpdate(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    ssh_host: Optional[str] = None
-    ssh_username: Optional[str] = None
-    ssh_private_key_path: Optional[str] = None
-    ssh_tasks_dir: Optional[str] = None
-    ssh_jobs_dir: Optional[str] = None
-    slurm_user: Optional[str] = None
-    slurm_accounts: Optional[list[StrictStr]] = None
-    project_dir: Optional[str] = None
+    ssh_host: Optional[NonEmptyString] = None
+    ssh_username: Optional[NonEmptyString] = None
+    ssh_private_key_path: Optional[NonEmptyString] = None
+    ssh_tasks_dir: Optional[NonEmptyString] = None
+    ssh_jobs_dir: Optional[NonEmptyString] = None
+    slurm_user: Optional[NonEmptyString] = None
+    slurm_accounts: Optional[list[NonEmptyString]] = None
+    project_dir: Optional[NonEmptyString] = None
 
-    _ssh_host = field_validator("ssh_host")(
-        classmethod(valstr("ssh_host", accept_none=True))
-    )
-    _ssh_username = field_validator("ssh_username")(
-        classmethod(valstr("ssh_username", accept_none=True))
-    )
     _ssh_private_key_path = field_validator("ssh_private_key_path")(
         classmethod(
             val_absolute_path("ssh_private_key_path", accept_none=True)
@@ -76,17 +70,11 @@ class UserSettingsUpdate(BaseModel):
         classmethod(val_absolute_path("ssh_jobs_dir", accept_none=True))
     )
 
-    _slurm_user = field_validator("slurm_user")(
-        classmethod(valstr("slurm_user", accept_none=True))
-    )
-
     @field_validator("slurm_accounts")
     @classmethod
     def slurm_accounts_validator(cls, value):
         if value is None:
             return value
-        for i, item in enumerate(value):
-            value[i] = valstr(f"slurm_accounts[{i}]")(cls, item)
         return val_unique_list("slurm_accounts")(cls, value)
 
     @field_validator("project_dir")