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

fractal_server/app/schemas/v2/dataset.py

@@ -5,40 +5,23 @@ from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
 from pydantic import field_serializer
-from pydantic import field_validator
-from pydantic import model_validator
 from pydantic.types import AwareDatetime
 
-from .._validators import cant_set_none
-from .._validators import NonEmptyString
-from .._validators import root_validate_dict_keys
-from .project import ProjectReadV2
+from fractal_server.app.schemas.v2.project import ProjectReadV2
 from fractal_server.images import SingleImage
-from fractal_server.images.models import AttributeFiltersType
-from fractal_server.urls import normalize_url
+from fractal_server.types import AttributeFilters
+from fractal_server.types import NonEmptyStr
+from fractal_server.types import ZarrDirStr
 
 
 class DatasetCreateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    name: NonEmptyString
+    name: NonEmptyStr
 
-    zarr_dir: Optional[str] = None
+    zarr_dir: Optional[ZarrDirStr] = None
 
-    attribute_filters: AttributeFiltersType = Field(default_factory=dict)
-
-    # Validators
-
-    _dict_keys = model_validator(mode="before")(
-        classmethod(root_validate_dict_keys)
-    )
-
-    @field_validator("zarr_dir")
-    @classmethod
-    def normalize_zarr_dir(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None:
-            return normalize_url(v)
-        return v
+    attribute_filters: AttributeFilters = Field(default_factory=dict)
 
 
 class DatasetReadV2(BaseModel):
@@ -60,26 +43,8 @@ class DatasetReadV2(BaseModel):
 class DatasetUpdateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    name: Optional[NonEmptyString] = None
-    zarr_dir: Optional[str] = None
-
-    # Validators
-
-    _dict_keys = model_validator(mode="before")(
-        classmethod(root_validate_dict_keys)
-    )
-
-    @field_validator("name")
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
-    @field_validator("zarr_dir")
-    @classmethod
-    def normalize_zarr_dir(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None:
-            return normalize_url(v)
-        return v
+    name: NonEmptyStr = None
+    zarr_dir: Optional[ZarrDirStr] = None
 
 
 class DatasetImportV2(BaseModel):
@@ -97,14 +62,9 @@ class DatasetImportV2(BaseModel):
     """
 
     name: str
-    zarr_dir: str
+    zarr_dir: ZarrDirStr
     images: list[SingleImage] = Field(default_factory=list)
 
-    @field_validator("zarr_dir")
-    @classmethod
-    def normalize_zarr_dir(cls, v: str) -> str:
-        return normalize_url(v)
-
 
 class DatasetExportV2(BaseModel):
     """

fractal_server/app/schemas/v2/job.py

@@ -6,21 +6,17 @@ from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
 from pydantic import field_serializer
-from pydantic import field_validator
 from pydantic import model_validator
-from pydantic import ValidationInfo
 from pydantic.types import AwareDatetime
+from pydantic.types import NonNegativeInt
 from pydantic.types import StrictStr
 
-from .._filter_validators import validate_attribute_filters
-from .._filter_validators import validate_type_filters
-from .._validators import cant_set_none
-from .._validators import NonEmptyString
-from .._validators import root_validate_dict_keys
-from .dumps import DatasetDumpV2
-from .dumps import ProjectDumpV2
-from .dumps import WorkflowDumpV2
-from fractal_server.images.models import AttributeFiltersType
+from fractal_server.app.schemas.v2.dumps import DatasetDumpV2
+from fractal_server.app.schemas.v2.dumps import ProjectDumpV2
+from fractal_server.app.schemas.v2.dumps import WorkflowDumpV2
+from fractal_server.types import AttributeFilters
+from fractal_server.types import NonEmptyStr
+from fractal_server.types import TypeFilters
 
 
 class JobStatusTypeV2(str, Enum):
@@ -47,64 +43,27 @@ class JobStatusTypeV2(str, Enum):
 class JobCreateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    first_task_index: Optional[int] = None
-    last_task_index: Optional[int] = None
+    first_task_index: Optional[NonNegativeInt] = None
+    last_task_index: Optional[NonNegativeInt] = None
     slurm_account: Optional[StrictStr] = None
-    worker_init: Optional[NonEmptyString] = None
-
-    attribute_filters: AttributeFiltersType = Field(default_factory=dict)
-    type_filters: dict[str, bool] = Field(default_factory=dict)
+    worker_init: NonEmptyStr = None
 
-    # Validators
+    attribute_filters: AttributeFilters = Field(default_factory=dict)
+    type_filters: TypeFilters = Field(default_factory=dict)
 
-    @field_validator("worker_init")
+    @model_validator(mode="before")
     @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
-    _dict_keys = model_validator(mode="before")(
-        classmethod(root_validate_dict_keys)
-    )
-    _attribute_filters = field_validator("attribute_filters")(
-        classmethod(validate_attribute_filters)
-    )
-    _type_filters = field_validator("type_filters")(
-        classmethod(validate_type_filters)
-    )
-
-    @field_validator("first_task_index")
-    @classmethod
-    def first_task_index_non_negative(cls, v):
-        """
-        Check that `first_task_index` is non-negative.
-        """
-        if v is not None and v < 0:
-            raise ValueError(
-                f"first_task_index cannot be negative (given: {v})"
-            )
-        return v
-
-    @field_validator("last_task_index")
-    @classmethod
-    def first_last_task_indices(cls, v, info: ValidationInfo):
-        """
-        Check that `last_task_index` is non-negative, and that it is not
-        smaller than `first_task_index`.
-        """
-        if v is not None and v < 0:
-            raise ValueError(
-                f"last_task_index cannot be negative (given: {v})"
-            )
-
-        first_task_index = info.data.get("first_task_index")
-        last_task_index = v
+    def validate_first_last_indices(cls, values):
+        first_task_index = values.get("first_task_index")
+        last_task_index = values.get("last_task_index")
+
         if first_task_index is not None and last_task_index is not None:
             if first_task_index > last_task_index:
                 raise ValueError(
                     f"{first_task_index=} cannot be larger than "
                     f"{last_task_index=}"
                 )
-        return v
+        return values
 
 
 class JobReadV2(BaseModel):
@@ -126,7 +85,7 @@ class JobReadV2(BaseModel):
     first_task_index: Optional[int] = None
     last_task_index: Optional[int] = None
     worker_init: Optional[str] = None
-    attribute_filters: AttributeFiltersType
+    attribute_filters: AttributeFilters
     type_filters: dict[str, bool]
 
     @field_serializer("start_timestamp")

fractal_server/app/schemas/v2/manifest.py

@@ -1,14 +1,13 @@
-from typing import Any
 from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import Field
-from pydantic import field_validator
-from pydantic import HttpUrl
 from pydantic import model_validator
 
-from .._validators import NonEmptyString
+from fractal_server.types import DictStrAny
+from fractal_server.types import HttpUrlStr
+from fractal_server.types import NonEmptyStr
 
 
 class TaskManifestV2(BaseModel):
@@ -46,12 +45,12 @@ class TaskManifestV2(BaseModel):
     executable_parallel: Optional[str] = None
     input_types: dict[str, bool] = Field(default_factory=dict)
     output_types: dict[str, bool] = Field(default_factory=dict)
-    meta_non_parallel: dict[str, Any] = Field(default_factory=dict)
-    meta_parallel: dict[str, Any] = Field(default_factory=dict)
-    args_schema_non_parallel: Optional[dict[str, Any]] = None
-    args_schema_parallel: Optional[dict[str, Any]] = None
+    meta_non_parallel: DictStrAny = Field(default_factory=dict)
+    meta_parallel: DictStrAny = Field(default_factory=dict)
+    args_schema_non_parallel: Optional[DictStrAny] = None
+    args_schema_parallel: Optional[DictStrAny] = None
     docs_info: Optional[str] = None
-    docs_link: Optional[str] = None
+    docs_link: Optional[HttpUrlStr] = None
 
     category: Optional[str] = None
     modality: Optional[str] = None
@@ -113,13 +112,6 @@ class TaskManifestV2(BaseModel):
 
         return self
 
-    @field_validator("docs_link", mode="after")
-    @classmethod
-    def validate_docs_link(cls, value):
-        if value is not None:
-            HttpUrl(value)
-        return value
-
 
 class ManifestV2(BaseModel):
     """
@@ -145,11 +137,11 @@ class ManifestV2(BaseModel):
             Label of how `args_schema`s were generated (e.g. `pydantic_v1`).
     """
 
-    manifest_version: str
+    manifest_version: Literal["2"]
     task_list: list[TaskManifestV2]
     has_args_schemas: bool = False
     args_schema_version: Optional[str] = None
-    authors: Optional[NonEmptyString] = None
+    authors: Optional[NonEmptyStr] = None
 
     @model_validator(mode="after")
     def _check_args_schemas_are_present(self):
@@ -185,10 +177,3 @@ class ManifestV2(BaseModel):
                 )
             )
         return self
-
-    @field_validator("manifest_version")
-    @classmethod
-    def manifest_version_2(cls, value):
-        if value != "2":
-            raise ValueError(f"Wrong manifest version (given {value})")
-        return value

fractal_server/app/schemas/v2/project.py

@@ -1,21 +1,18 @@
 from datetime import datetime
-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 fractal_server.types import NonEmptyStr
 
 
 class ProjectCreateV2(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    name: NonEmptyString
+    name: NonEmptyStr
 
 
 class ProjectReadV2(BaseModel):
@@ -33,9 +30,4 @@ class ProjectUpdateV2(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    name: Optional[NonEmptyString] = None
-
-    @field_validator("name")
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
+    name: NonEmptyStr = None

fractal_server/app/schemas/v2/task.py

@@ -5,16 +5,15 @@ from typing import Optional
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
-from pydantic import field_validator
-from pydantic import HttpUrl
 from pydantic import model_validator
 
-from .._validators import cant_set_none
-from fractal_server.app.schemas._validators import NonEmptyString
-from fractal_server.app.schemas._validators import val_unique_list
-from fractal_server.app.schemas._validators import valdict_keys
 from fractal_server.logger import set_logger
 from fractal_server.string_tools import validate_cmd
+from fractal_server.types import DictStrAny
+from fractal_server.types import HttpUrlStr
+from fractal_server.types import ListUniqueNonEmptyString
+from fractal_server.types import NonEmptyStr
+from fractal_server.types import TypeFilters
 
 TaskTypeType = Literal[
     "compound",
@@ -31,42 +30,30 @@ logger = set_logger(__name__)
 class TaskCreateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    name: NonEmptyString
+    name: NonEmptyStr
 
-    command_non_parallel: Optional[NonEmptyString] = None
-    command_parallel: Optional[NonEmptyString] = None
+    command_non_parallel: NonEmptyStr = None
+    command_parallel: NonEmptyStr = None
 
-    meta_non_parallel: Optional[dict[str, Any]] = None
-    meta_parallel: Optional[dict[str, Any]] = None
-    version: Optional[NonEmptyString] = None
-    args_schema_non_parallel: Optional[dict[str, Any]] = None
-    args_schema_parallel: Optional[dict[str, Any]] = None
-    args_schema_version: Optional[NonEmptyString] = None
+    meta_non_parallel: Optional[DictStrAny] = None
+    meta_parallel: Optional[DictStrAny] = None
+    version: NonEmptyStr = None
+    args_schema_non_parallel: Optional[DictStrAny] = None
+    args_schema_parallel: Optional[DictStrAny] = None
+    args_schema_version: NonEmptyStr = None
     docs_info: Optional[str] = None
-    docs_link: Optional[str] = None
+    docs_link: Optional[HttpUrlStr] = None
 
-    input_types: dict[str, bool] = Field(default={})
-    output_types: dict[str, bool] = Field(default={})
+    input_types: TypeFilters = Field(default={})
+    output_types: TypeFilters = Field(default={})
 
-    category: Optional[NonEmptyString] = None
-    modality: Optional[NonEmptyString] = None
-    tags: list[NonEmptyString] = Field(default_factory=list)
-    authors: Optional[NonEmptyString] = None
+    category: Optional[NonEmptyStr] = None
+    modality: Optional[NonEmptyStr] = None
+    tags: ListUniqueNonEmptyString = Field(default_factory=list)
+    authors: Optional[NonEmptyStr] = None
 
     type: Optional[TaskTypeType] = None
 
-    # Validators
-
-    @field_validator(
-        "command_non_parallel",
-        "command_parallel",
-        "version",
-        "args_schema_version",
-    )
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
     @model_validator(mode="after")
     def validate_commands(self):
         command_parallel = self.command_parallel
@@ -100,37 +87,6 @@ class TaskCreateV2(BaseModel):
 
         return self
 
-    _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_schema_non_parallel = field_validator("args_schema_non_parallel")(
-        classmethod(valdict_keys("args_schema_non_parallel"))
-    )
-    _args_schema_parallel = field_validator("args_schema_parallel")(
-        classmethod(valdict_keys("args_schema_parallel"))
-    )
-    _input_types = field_validator("input_types")(
-        classmethod(valdict_keys("input_types"))
-    )
-    _output_types = field_validator("output_types")(
-        classmethod(valdict_keys("output_types"))
-    )
-
-    @field_validator("tags")
-    @classmethod
-    def validate_list_of_strings(cls, value):
-        return val_unique_list("tags")(cls, value)
-
-    @field_validator("docs_link", mode="after")
-    @classmethod
-    def validate_docs_link(cls, value):
-        if value is not None:
-            HttpUrl(value)
-        return value
-
 
 class TaskReadV2(BaseModel):
     id: int
@@ -162,56 +118,30 @@ class TaskReadV2(BaseModel):
 class TaskUpdateV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    command_parallel: Optional[NonEmptyString] = None
-    command_non_parallel: Optional[NonEmptyString] = None
-    input_types: Optional[dict[str, bool]] = None
-    output_types: Optional[dict[str, bool]] = None
-
-    category: Optional[NonEmptyString] = None
-    modality: Optional[NonEmptyString] = None
-    authors: Optional[NonEmptyString] = None
-    tags: Optional[list[NonEmptyString]] = None
-
-    # Validators
-
-    @field_validator("command_parallel", "command_non_parallel")
-    @classmethod
-    def _cant_set_none(cls, v):
-        return cant_set_none(v)
-
-    @field_validator("input_types", "output_types")
-    @classmethod
-    def val_is_dict(cls, v):
-        if not isinstance(v, dict):
-            raise ValueError
-        return v
-
-    _input_types = field_validator("input_types")(
-        classmethod(valdict_keys("input_types"))
-    )
-    _output_types = field_validator("output_types")(
-        classmethod(valdict_keys("output_types"))
-    )
+    command_parallel: NonEmptyStr = None
+    command_non_parallel: NonEmptyStr = None
+    input_types: TypeFilters = None
+    output_types: TypeFilters = None
 
-    @field_validator("tags")
-    @classmethod
-    def validate_tags(cls, value):
-        return val_unique_list("tags")(cls, value)
+    category: Optional[NonEmptyStr] = None
+    modality: Optional[NonEmptyStr] = None
+    authors: Optional[NonEmptyStr] = None
+    tags: Optional[ListUniqueNonEmptyString] = None
 
 
 class TaskImportV2(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    pkg_name: NonEmptyString
-    version: Optional[NonEmptyString] = None
-    name: NonEmptyString
+    pkg_name: NonEmptyStr
+    version: Optional[NonEmptyStr] = None
+    name: NonEmptyStr
 
 
 class TaskImportV2Legacy(BaseModel):
-    source: NonEmptyString
+    source: NonEmptyStr
 
 
 class TaskExportV2(BaseModel):
-    pkg_name: NonEmptyString
-    version: Optional[NonEmptyString] = None
-    name: NonEmptyString
+    pkg_name: NonEmptyStr
+    version: Optional[NonEmptyStr] = None
+    name: NonEmptyStr

fractal_server/app/schemas/v2/task_collection.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Literal
 from typing import Optional
 
@@ -7,9 +6,11 @@ from pydantic import ConfigDict
 from pydantic import field_validator
 from pydantic import model_validator
 
-from .._validators import NonEmptyString
 from fractal_server.app.schemas.v2 import ManifestV2
 from fractal_server.string_tools import validate_cmd
+from fractal_server.types import AbsolutePathStr
+from fractal_server.types import DictStrStr
+from fractal_server.types import NonEmptyStr
 
 
 class WheelFile(BaseModel):
@@ -46,57 +47,28 @@ class TaskCollectPipV2(BaseModel):
     """
 
     model_config = ConfigDict(extra="forbid")
-    package: Optional[NonEmptyString] = None
-    package_version: Optional[NonEmptyString] = None
-    package_extras: Optional[NonEmptyString] = None
+    package: Optional[NonEmptyStr] = None
+    package_version: Optional[NonEmptyStr] = None
+    package_extras: Optional[NonEmptyStr] = None
     python_version: Optional[Literal["3.9", "3.10", "3.11", "3.12"]] = None
-    pinned_package_versions: Optional[dict[str, str]] = None
+    pinned_package_versions: Optional[DictStrStr] = None
 
-    @field_validator("package")
+    @field_validator(
+        "package", "package_version", "package_extras", mode="after"
+    )
     @classmethod
-    def package_validator(cls, value: Optional[str]) -> Optional[str]:
-        if value is None:
-            return value
-        validate_cmd(value, attribute_name="package")
-        return value
-
-    @field_validator("package_version")
-    @classmethod
-    def package_version_validator(cls, value: Optional[str]) -> Optional[str]:
-        if value is None:
-            return value
-        validate_cmd(value, attribute_name="package_version")
-        return value
-
-    @field_validator("pinned_package_versions")
-    @classmethod
-    def pinned_package_versions_validator(cls, value):
-        if value is None:
-            return value
-
-        old_keys = list(value.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: {value}."
-            )
-        for old_key, new_key in zip(old_keys, new_keys):
-            if new_key != old_key:
-                value[new_key] = value.pop(old_key)
-
-        for pkg, version in value.items():
-            validate_cmd(pkg)
-            validate_cmd(version)
+    def validate_commands(cls, value):
+        if value is not None:
+            validate_cmd(value)
         return value
 
-    @field_validator("package_extras")
+    @field_validator("pinned_package_versions", mode="after")
     @classmethod
-    def package_extras_validator(cls, value: Optional[str]) -> Optional[str]:
-        if value is None:
-            return value
-        validate_cmd(value, attribute_name="package_extras")
+    def validate_pinned_package_versions(cls, value):
+        if value is not None:
+            for pkg, version in value.items():
+                validate_cmd(pkg)
+                validate_cmd(version)
         return value
 
 
@@ -120,11 +92,18 @@ class TaskCollectCustomV2(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
     manifest: ManifestV2
-    python_interpreter: NonEmptyString
-    label: NonEmptyString
-    package_root: Optional[NonEmptyString] = None
-    package_name: Optional[NonEmptyString] = None
-    version: Optional[NonEmptyString] = None
+    python_interpreter: AbsolutePathStr
+    label: NonEmptyStr
+    package_root: Optional[AbsolutePathStr] = None
+    package_name: Optional[NonEmptyStr] = None
+    version: Optional[NonEmptyStr] = None
+
+    @field_validator("package_name", mode="after")
+    @classmethod
+    def validate_package_name(cls, value):
+        if value is not None:
+            validate_cmd(value)
+        return value
 
     @model_validator(mode="before")
     @classmethod
@@ -139,32 +118,3 @@ class TaskCollectCustomV2(BaseModel):
                 "'package_root' and 'package_name'"
             )
         return values
-
-    @field_validator("package_name")
-    @classmethod
-    def package_name_validator(cls, value: str):
-        """
-        Remove all whitespace characters, then check for invalid code.
-        """
-        if value is not None:
-            validate_cmd(value)
-            value = value.replace(" ", "")
-        return value
-
-    @field_validator("package_root")
-    @classmethod
-    def package_root_validator(cls, value):
-        if (value is not None) and (not Path(value).is_absolute()):
-            raise ValueError(
-                f"'package_root' must be an absolute path: (given {value})."
-            )
-        return value
-
-    @field_validator("python_interpreter")
-    @classmethod
-    def python_interpreter_validator(cls, value):
-        if not Path(value).is_absolute():
-            raise ValueError(
-                f"Python interpreter path must be absolute: (given {value})."
-            )
-        return value