fractal-server 2.14.3a0__py3-none-any.whl → 2.14.4__py3-none-any.whl

fractal_server/app/schemas/v2/task_group.py

@@ -6,14 +6,12 @@ from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
 from pydantic import field_serializer
-from pydantic import field_validator
 from pydantic.types import AwareDatetime
 
-from .._validators import cant_set_none
-from .._validators import NonEmptyString
-from .._validators import val_absolute_path
-from .._validators import valdict_keys
-from .task import TaskReadV2
+from fractal_server.app.schemas.v2.task import TaskReadV2
+from fractal_server.types import AbsolutePathStr
+from fractal_server.types import DictStrStr
+from fractal_server.types import NonEmptyStr
 
 
 class TaskGroupV2OriginEnum(str, Enum):
@@ -43,31 +41,13 @@ class TaskGroupCreateV2(BaseModel):
     origin: TaskGroupV2OriginEnum
     pkg_name: str
     version: Optional[str] = None
-    python_version: Optional[NonEmptyString] = None
-    path: Optional[str] = None
-    venv_path: Optional[str] = None
-    wheel_path: Optional[str] = None
-    pip_extras: Optional[NonEmptyString] = None
+    python_version: NonEmptyStr = None
+    path: AbsolutePathStr = None
+    venv_path: AbsolutePathStr = None
+    wheel_path: AbsolutePathStr = None
+    pip_extras: NonEmptyStr = None
     pip_freeze: Optional[str] = None
-    pinned_package_versions: dict[str, str] = Field(default_factory=dict)
-
-    # Validators
-
-    @field_validator("python_version", "pip_extras")
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
-    _path = field_validator("path")(classmethod(val_absolute_path("path")))
-    _venv_path = field_validator("venv_path")(
-        classmethod(val_absolute_path("venv_path"))
-    )
-    _wheel_path = field_validator("wheel_path")(
-        classmethod(val_absolute_path("wheel_path"))
-    )
-    _pinned_package_versions = field_validator("pinned_package_versions")(
-        valdict_keys("pinned_package_versions")
-    )
+    pinned_package_versions: DictStrStr = Field(default_factory=dict)
 
 
 class TaskGroupCreateV2Strict(TaskGroupCreateV2):
@@ -75,10 +55,10 @@ class TaskGroupCreateV2Strict(TaskGroupCreateV2):
     A strict version of TaskGroupCreateV2, to be used for task collection.
     """
 
-    path: str
-    venv_path: str
-    version: str
-    python_version: str
+    path: AbsolutePathStr
+    venv_path: AbsolutePathStr
+    version: NonEmptyStr
+    python_version: NonEmptyStr
 
 
 class TaskGroupReadV2(BaseModel):

fractal_server/app/schemas/v2/workflow.py

@@ -4,23 +4,24 @@ from typing import Optional
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import field_serializer
-from pydantic import field_validator
 from pydantic.types import AwareDatetime
 
-from .._validators import cant_set_none
-from .._validators import NonEmptyString
-from .project import ProjectReadV2
-from .workflowtask import WorkflowTaskExportV2
-from .workflowtask import WorkflowTaskImportV2
-from .workflowtask import WorkflowTaskReadV2
-from .workflowtask import WorkflowTaskReadV2WithWarning
+from fractal_server.app.schemas.v2.project import ProjectReadV2
+from fractal_server.app.schemas.v2.workflowtask import WorkflowTaskExportV2
+from fractal_server.app.schemas.v2.workflowtask import WorkflowTaskImportV2
+from fractal_server.app.schemas.v2.workflowtask import WorkflowTaskReadV2
+from fractal_server.app.schemas.v2.workflowtask import (
+    WorkflowTaskReadV2WithWarning,
+)
+from fractal_server.types import ListUniqueNonNegativeInt
+from fractal_server.types import NonEmptyStr
 
 
 class WorkflowCreateV2(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    name: NonEmptyString
+    name: NonEmptyStr
 
 
 class WorkflowReadV2(BaseModel):
@@ -45,24 +46,8 @@ class WorkflowUpdateV2(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    name: Optional[NonEmptyString] = None
-    reordered_workflowtask_ids: Optional[list[int]] = None
-
-    # Validators
-
-    @field_validator("name")
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
-    @field_validator("reordered_workflowtask_ids")
-    @classmethod
-    def check_positive_and_unique(cls, value):
-        if any(i < 0 for i in value):
-            raise ValueError("Negative `id` in `reordered_workflowtask_ids`")
-        if len(value) != len(set(value)):
-            raise ValueError("`reordered_workflowtask_ids` has repetitions")
-        return value
+    name: NonEmptyStr = None
+    reordered_workflowtask_ids: Optional[ListUniqueNonNegativeInt] = None
 
 
 class WorkflowImportV2(BaseModel):
@@ -74,7 +59,7 @@ class WorkflowImportV2(BaseModel):
     """
 
     model_config = ConfigDict(extra="forbid")
-    name: NonEmptyString
+    name: NonEmptyStr
     task_list: list[WorkflowTaskImportV2]
 
 

fractal_server/app/schemas/v2/workflowtask.py

@@ -5,73 +5,26 @@ from typing import Union
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
-from pydantic import field_validator
 from pydantic import model_validator
 
-from .._filter_validators import validate_type_filters
-from .._validators import root_validate_dict_keys
-from .._validators import valdict_keys
 from .task import TaskExportV2
 from .task import TaskImportV2
 from .task import TaskImportV2Legacy
 from .task import TaskReadV2
 from .task import TaskTypeType
-
-RESERVED_ARGUMENTS = {"zarr_dir", "zarr_url", "zarr_urls", "init_args"}
+from fractal_server.types import DictStrAny
+from fractal_server.types import TypeFilters
+from fractal_server.types import WorkflowTaskArgument
 
 
 class WorkflowTaskCreateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    meta_non_parallel: Optional[dict[str, Any]] = None
-    meta_parallel: Optional[dict[str, Any]] = None
-    args_non_parallel: Optional[dict[str, Any]] = None
-    args_parallel: Optional[dict[str, Any]] = None
-    type_filters: dict[str, bool] = Field(default_factory=dict)
-
-    # Validators
-    _dict_keys = model_validator(mode="before")(
-        classmethod(root_validate_dict_keys)
-    )
-    _type_filters = field_validator("type_filters")(
-        classmethod(validate_type_filters)
-    )
-    _meta_non_parallel = field_validator("meta_non_parallel")(
-        classmethod(valdict_keys("meta_non_parallel"))
-    )
-    _meta_parallel = field_validator("meta_parallel")(
-        classmethod(valdict_keys("meta_parallel"))
-    )
-
-    @field_validator("args_non_parallel")
-    @classmethod
-    def validate_args_non_parallel(cls, value):
-        if value is None:
-            return
-        valdict_keys("args_non_parallel")(cls, value)
-        args_keys = set(value.keys())
-        intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
-        if intersect_keys:
-            raise ValueError(
-                "`args` contains the following forbidden keys: "
-                f"{intersect_keys}"
-            )
-        return value
-
-    @field_validator("args_parallel")
-    @classmethod
-    def validate_args_parallel(cls, value):
-        if value is None:
-            return
-        valdict_keys("args_parallel")(cls, value)
-        args_keys = set(value.keys())
-        intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
-        if intersect_keys:
-            raise ValueError(
-                "`args` contains the following forbidden keys: "
-                f"{intersect_keys}"
-            )
-        return value
+    meta_non_parallel: Optional[DictStrAny] = None
+    meta_parallel: Optional[DictStrAny] = None
+    args_non_parallel: Optional[WorkflowTaskArgument] = None
+    args_parallel: Optional[WorkflowTaskArgument] = None
+    type_filters: TypeFilters = Field(default_factory=dict)
 
 
 class WorkflowTaskReplaceV2(BaseModel):
@@ -106,70 +59,25 @@ class WorkflowTaskReadV2WithWarning(WorkflowTaskReadV2):
 class WorkflowTaskUpdateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    meta_non_parallel: Optional[dict[str, Any]] = None
-    meta_parallel: Optional[dict[str, Any]] = None
-    args_non_parallel: Optional[dict[str, Any]] = None
-    args_parallel: Optional[dict[str, Any]] = None
-    type_filters: Optional[dict[str, bool]] = None
-
-    # Validators
-    _dict_keys = model_validator(mode="before")(
-        classmethod(root_validate_dict_keys)
-    )
-    _type_filters = field_validator("type_filters")(
-        classmethod(validate_type_filters)
-    )
-    _meta_non_parallel = field_validator("meta_non_parallel")(
-        classmethod(valdict_keys("meta_non_parallel"))
-    )
-    _meta_parallel = field_validator("meta_parallel")(
-        classmethod(valdict_keys("meta_parallel"))
-    )
-
-    @field_validator("args_non_parallel")
-    @classmethod
-    def validate_args_non_parallel(cls, value):
-        if value is None:
-            return
-        valdict_keys("args_non_parallel")(cls, value)
-        args_keys = set(value.keys())
-        intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
-        if intersect_keys:
-            raise ValueError(
-                "`args` contains the following forbidden keys: "
-                f"{intersect_keys}"
-            )
-        return value
-
-    @field_validator("args_parallel")
-    @classmethod
-    def validate_args_parallel(cls, value):
-        if value is None:
-            return
-        valdict_keys("args_parallel")(cls, value)
-        args_keys = set(value.keys())
-        intersect_keys = RESERVED_ARGUMENTS.intersection(args_keys)
-        if intersect_keys:
-            raise ValueError(
-                "`args` contains the following forbidden keys: "
-                f"{intersect_keys}"
-            )
-        return value
+    meta_non_parallel: Optional[DictStrAny] = None
+    meta_parallel: Optional[DictStrAny] = None
+    args_non_parallel: Optional[WorkflowTaskArgument] = None
+    args_parallel: Optional[WorkflowTaskArgument] = None
+    type_filters: TypeFilters = None
 
 
 class WorkflowTaskImportV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    meta_non_parallel: Optional[dict[str, Any]] = None
-    meta_parallel: Optional[dict[str, Any]] = None
-    args_non_parallel: Optional[dict[str, Any]] = None
-    args_parallel: Optional[dict[str, Any]] = None
-    type_filters: Optional[dict[str, bool]] = None
+    meta_non_parallel: Optional[DictStrAny] = None
+    meta_parallel: Optional[DictStrAny] = None
+    args_non_parallel: Optional[DictStrAny] = None
+    args_parallel: Optional[DictStrAny] = None
+    type_filters: Optional[TypeFilters] = None
     input_filters: Optional[dict[str, Any]] = None
 
     task: Union[TaskImportV2, TaskImportV2Legacy]
 
-    # Validators
     @model_validator(mode="before")
     @classmethod
     def update_legacy_filters(cls, values: dict):
@@ -198,22 +106,6 @@ class WorkflowTaskImportV2(BaseModel):
 
         return values
 
-    _type_filters = field_validator("type_filters")(
-        classmethod(validate_type_filters)
-    )
-    _meta_non_parallel = field_validator("meta_non_parallel")(
-        classmethod(valdict_keys("meta_non_parallel"))
-    )
-    _meta_parallel = field_validator("meta_parallel")(
-        classmethod(valdict_keys("meta_parallel"))
-    )
-    _args_non_parallel = field_validator("args_non_parallel")(
-        classmethod(valdict_keys("args_non_parallel"))
-    )
-    _args_parallel = field_validator("args_parallel")(
-        classmethod(valdict_keys("args_parallel"))
-    )
-
 
 class WorkflowTaskExportV2(BaseModel):
     meta_non_parallel: Optional[dict[str, Any]] = None

fractal_server/config.py

@@ -34,6 +34,7 @@ from pydantic_settings import SettingsConfigDict
 from sqlalchemy.engine import URL
 
 import fractal_server
+from fractal_server.types import AbsolutePathStr
 
 
 class MailSettings(BaseModel):
@@ -280,45 +281,27 @@ class Settings(BaseSettings):
     or a path relative to current working directory).
     """
 
-    @field_validator("FRACTAL_TASKS_DIR")
-    @classmethod
-    def make_FRACTAL_TASKS_DIR_absolute(cls, v):
-        """
-        If `FRACTAL_TASKS_DIR` is a non-absolute path, make it absolute (based
-        on the current working directory).
-        """
-        if v is None:
-            return None
-        FRACTAL_TASKS_DIR_path = Path(v)
-        if not FRACTAL_TASKS_DIR_path.is_absolute():
-            FRACTAL_TASKS_DIR_path = FRACTAL_TASKS_DIR_path.resolve()
-            logging.warning(
-                f'FRACTAL_TASKS_DIR="{v}" is not an absolute path; '
-                f'converting it to "{str(FRACTAL_TASKS_DIR_path)}"'
-            )
-        return FRACTAL_TASKS_DIR_path
+    FRACTAL_RUNNER_WORKING_BASE_DIR: Optional[Path] = None
+    """
+    Base directory for job files (either an absolute path or a path relative to
+    current working directory).
+    """
 
-    @field_validator("FRACTAL_RUNNER_WORKING_BASE_DIR")
+    @field_validator(
+        "FRACTAL_TASKS_DIR",
+        "FRACTAL_RUNNER_WORKING_BASE_DIR",
+        mode="after",
+    )
     @classmethod
-    def make_FRACTAL_RUNNER_WORKING_BASE_DIR_absolute(cls, v):
-        """
-        (Copy of make_FRACTAL_TASKS_DIR_absolute)
-        If `FRACTAL_RUNNER_WORKING_BASE_DIR` is a non-absolute path,
-        make it absolute (based on the current working directory).
-        """
-        if v is None:
-            return None
-        FRACTAL_RUNNER_WORKING_BASE_DIR_path = Path(v)
-        if not FRACTAL_RUNNER_WORKING_BASE_DIR_path.is_absolute():
-            FRACTAL_RUNNER_WORKING_BASE_DIR_path = (
-                FRACTAL_RUNNER_WORKING_BASE_DIR_path.resolve()
-            )
+    def make_paths_absolute(cls, path: Optional[Path]) -> Optional[Path]:
+        if path is None or path.is_absolute():
+            return path
+        else:
             logging.warning(
-                f'FRACTAL_RUNNER_WORKING_BASE_DIR="{v}" is not an absolute '
-                "path; converting it to "
-                f'"{str(FRACTAL_RUNNER_WORKING_BASE_DIR_path)}"'
+                f"'{path}' is not an absolute path; "
+                f"converting it to '{path.resolve()}'"
             )
-        return FRACTAL_RUNNER_WORKING_BASE_DIR_path
+            return path.resolve()
 
     FRACTAL_RUNNER_BACKEND: Literal[
         "local",
@@ -329,12 +312,6 @@ class Settings(BaseSettings):
     Select which runner backend to use.
     """
 
-    FRACTAL_RUNNER_WORKING_BASE_DIR: Optional[Path] = None
-    """
-    Base directory for running jobs / workflows. All artifacts required to set
-    up, run and tear down jobs are placed in subdirs of this directory.
-    """
-
     FRACTAL_LOGGING_LEVEL: int = logging.INFO
     """
     Logging-level threshold for logging
@@ -363,27 +340,12 @@ class Settings(BaseSettings):
     Path of JSON file with configuration for the SLURM backend.
     """
 
-    FRACTAL_SLURM_WORKER_PYTHON: Optional[str] = None
+    FRACTAL_SLURM_WORKER_PYTHON: Optional[AbsolutePathStr] = None
     """
     Absolute path to Python interpreter that will run the jobs on the SLURM
     nodes. If not specified, the same interpreter that runs the server is used.
     """
 
-    @field_validator("FRACTAL_SLURM_WORKER_PYTHON")
-    @classmethod
-    def absolute_FRACTAL_SLURM_WORKER_PYTHON(cls, v):
-        """
-        If `FRACTAL_SLURM_WORKER_PYTHON` is a relative path, fail.
-        """
-        if v is None:
-            return None
-        elif not Path(v).is_absolute():
-            raise FractalConfigurationError(
-                f"Non-absolute value for FRACTAL_SLURM_WORKER_PYTHON={v}"
-            )
-        else:
-            return v
-
     FRACTAL_TASKS_PYTHON_DEFAULT_VERSION: Optional[
         Literal["3.9", "3.10", "3.11", "3.12"]
     ] = None
@@ -507,27 +469,12 @@ class Settings(BaseSettings):
     `JobExecutionError`.
     """
 
-    FRACTAL_PIP_CACHE_DIR: Optional[str] = None
+    FRACTAL_PIP_CACHE_DIR: Optional[AbsolutePathStr] = None
     """
     Absolute path to the cache directory for `pip`; if unset,
     `--no-cache-dir` is used.
     """
 
-    @field_validator("FRACTAL_PIP_CACHE_DIR")
-    @classmethod
-    def absolute_FRACTAL_PIP_CACHE_DIR(cls, v):
-        """
-        If `FRACTAL_PIP_CACHE_DIR` is a relative path, fail.
-        """
-        if v is None:
-            return None
-        elif not Path(v).is_absolute():
-            raise FractalConfigurationError(
-                f"Non-absolute value for FRACTAL_PIP_CACHE_DIR={v}"
-            )
-        else:
-            return v
-
     @property
     def PIP_CACHE_DIR_ARG(self) -> str:
         """

fractal_server/images/models.py

@@ -1,15 +1,14 @@
-from typing import Any
 from typing import Optional
-from typing import Union
 
 from pydantic import BaseModel
 from pydantic import Field
-from pydantic import field_validator
 
-from fractal_server.app.schemas._validators import valdict_keys
-from fractal_server.urls import normalize_url
-
-AttributeFiltersType = dict[str, list[Any]]
+from fractal_server.types import DictStrAny
+from fractal_server.types import ImageAttributes
+from fractal_server.types import ImageAttributesWithNone
+from fractal_server.types import ImageTypes
+from fractal_server.types import ZarrDirStr
+from fractal_server.types import ZarrUrlStr
 
 
 class _SingleImageBase(BaseModel):
@@ -23,28 +22,11 @@ class _SingleImageBase(BaseModel):
         types:
     """
 
-    zarr_url: str
-    origin: Optional[str] = None
-
-    attributes: dict[str, Any] = Field(default_factory=dict)
-    types: dict[str, bool] = Field(default_factory=dict)
-
-    # Validators
-    _attributes = field_validator("attributes")(
-        classmethod(valdict_keys("attributes"))
-    )
-    _types = field_validator("types")(classmethod(valdict_keys("types")))
-
-    @field_validator("zarr_url")
-    @classmethod
-    def normalize_zarr_url(cls, v: str) -> str:
-        return normalize_url(v)
+    zarr_url: ZarrUrlStr
+    origin: Optional[ZarrDirStr] = None
 
-    @field_validator("origin")
-    @classmethod
-    def normalize_orig(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None:
-            return normalize_url(v)
+    attributes: DictStrAny = Field(default_factory=dict)
+    types: ImageTypes = Field(default_factory=dict)
 
 
 class SingleImageTaskOutput(_SingleImageBase):
@@ -52,19 +34,7 @@ class SingleImageTaskOutput(_SingleImageBase):
     `SingleImageBase`, with scalar `attributes` values (`None` included).
     """
 
-    @field_validator("attributes")
-    @classmethod
-    def validate_attributes(
-        cls, v: dict[str, Any]
-    ) -> dict[str, Union[int, float, str, bool, None]]:
-        for key, value in v.items():
-            if not isinstance(value, (int, float, str, bool, type(None))):
-                raise ValueError(
-                    f"SingleImageTaskOutput.attributes[{key}] must be a "
-                    "scalar (int, float, str or bool). "
-                    f"Given {value} ({type(value)})"
-                )
-        return v
+    attributes: ImageAttributesWithNone = Field(default_factory=dict)
 
 
 class SingleImage(_SingleImageBase):
@@ -72,46 +42,10 @@ class SingleImage(_SingleImageBase):
     `SingleImageBase`, with scalar `attributes` values (`None` excluded).
     """
 
-    @field_validator("attributes")
-    @classmethod
-    def validate_attributes(
-        cls, v: dict[str, Any]
-    ) -> dict[str, Union[int, float, str, bool]]:
-        for key, value in v.items():
-            if not isinstance(value, (int, float, str, bool)):
-                raise ValueError(
-                    f"SingleImage.attributes[{key}] must be a scalar "
-                    f"(int, float, str or bool). Given {value} ({type(value)})"
-                )
-        return v
+    attributes: ImageAttributes = Field(default_factory=dict)
 
 
 class SingleImageUpdate(BaseModel):
-    zarr_url: str
-    attributes: Optional[dict[str, Any]] = None
-    types: Optional[dict[str, bool]] = None
-
-    @field_validator("zarr_url")
-    @classmethod
-    def normalize_zarr_url(cls, v: str) -> str:
-        return normalize_url(v)
-
-    @field_validator("attributes")
-    @classmethod
-    def validate_attributes(
-        cls, v: dict[str, Any]
-    ) -> dict[str, Union[int, float, str, bool]]:
-        if v is not None:
-            # validate keys
-            valdict_keys("attributes")(cls, v)
-            # validate values
-            for key, value in v.items():
-                if not isinstance(value, (int, float, str, bool)):
-                    raise ValueError(
-                        f"SingleImageUpdate.attributes[{key}] must be a scalar"
-                        " (int, float, str or bool). "
-                        f"Given {value} ({type(value)})"
-                    )
-        return v
-
-    _types = field_validator("types")(classmethod(valdict_keys("types")))
+    zarr_url: ZarrUrlStr
+    attributes: ImageAttributes = None
+    types: Optional[ImageTypes] = None

fractal_server/images/tools.py

@@ -4,7 +4,7 @@ from typing import Literal
 from typing import Optional
 from typing import Union
 
-from fractal_server.images.models import AttributeFiltersType
+from fractal_server.types import AttributeFilters
 
 ImageSearch = dict[Literal["image", "index"], Union[int, dict[str, Any]]]
 
@@ -36,7 +36,7 @@ def match_filter(
     *,
     image: dict[str, Any],
     type_filters: dict[str, bool],
-    attribute_filters: AttributeFiltersType,
+    attribute_filters: AttributeFilters,
 ) -> bool:
     """
     Find whether an image matches a filter set.
@@ -66,7 +66,7 @@ def match_filter(
 def filter_image_list(
     images: list[dict[str, Any]],
     type_filters: Optional[dict[str, bool]] = None,
-    attribute_filters: Optional[AttributeFiltersType] = None,
+    attribute_filters: Optional[AttributeFilters] = None,
 ) -> list[dict[str, Any]]:
     """
     Compute a sublist with images that match a filter set.

fractal_server/ssh/_fabric.py

@@ -56,6 +56,7 @@ def _acquire_lock_with_timeout(
     """
     logger = get_logger(logger_name)
     logger.info(f"Trying to acquire lock for '{label}', with {timeout=}")
+    t_start_lock_acquire = time.perf_counter()
     result = lock.acquire(timeout=timeout)
     try:
         if not result:
@@ -64,7 +65,9 @@ def _acquire_lock_with_timeout(
                 f"Failed to acquire lock for '{label}' within "
                 f"{timeout} seconds"
             )
-        logger.info(f"Lock for '{label}' was acquired.")
+        t_end_lock_acquire = time.perf_counter()
+        elapsed = t_end_lock_acquire - t_start_lock_acquire
+        logger.info(f"Lock for '{label}' was acquired - {elapsed=:.4f} s")
         yield result
     finally:
         if result: