fractal-server 2.6.4__py3-none-any.whl → 2.7.0__py3-none-any.whl

fractal_server/app/schemas/v2/task.py

@@ -9,8 +9,9 @@ from pydantic import HttpUrl
 from pydantic import root_validator
 from pydantic import validator
 
-from .._validators import valdictkeys
-from .._validators import valstr
+from fractal_server.app.schemas._validators import val_unique_list
+from fractal_server.app.schemas._validators import valdictkeys
+from fractal_server.app.schemas._validators import valstr
 from fractal_server.string_tools import validate_cmd
 
 
@@ -18,22 +19,26 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
 
     name: str
 
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
-    source: str
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
 
-    meta_non_parallel: Optional[dict[str, Any]]
-    meta_parallel: Optional[dict[str, Any]]
-    version: Optional[str]
-    args_schema_non_parallel: Optional[dict[str, Any]]
-    args_schema_parallel: Optional[dict[str, Any]]
-    args_schema_version: Optional[str]
-    docs_info: Optional[str]
-    docs_link: Optional[HttpUrl]
+    meta_non_parallel: Optional[dict[str, Any]] = None
+    meta_parallel: Optional[dict[str, Any]] = None
+    version: Optional[str] = None
+    args_schema_non_parallel: Optional[dict[str, Any]] = None
+    args_schema_parallel: Optional[dict[str, Any]] = None
+    args_schema_version: Optional[str] = None
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
 
     input_types: dict[str, bool] = Field(default={})
     output_types: dict[str, bool] = Field(default={})
 
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    tags: list[str] = Field(default_factory=list)
+    authors: Optional[str] = None
+
     # Validators
     @root_validator
     def validate_commands(cls, values):
@@ -58,7 +63,6 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
     _command_parallel = validator("command_parallel", allow_reuse=True)(
         valstr("command_parallel")
     )
-    _source = validator("source", allow_reuse=True)(valstr("source"))
     _version = validator("version", allow_reuse=True)(valstr("version"))
 
     _meta_non_parallel = validator("meta_non_parallel", allow_reuse=True)(
@@ -83,37 +87,62 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
         valdictkeys("output_types")
     )
 
+    _category = validator("category", allow_reuse=True)(
+        valstr("category", accept_none=True)
+    )
+    _modality = validator("modality", allow_reuse=True)(
+        valstr("modality", accept_none=True)
+    )
+    _authors = validator("authors", allow_reuse=True)(
+        valstr("authors", accept_none=True)
+    )
+
+    @validator("tags")
+    def validate_list_of_strings(cls, value):
+        for i, tag in enumerate(value):
+            value[i] = valstr(f"tags[{i}]")(tag)
+        return val_unique_list("tags")(value)
+
 
 class TaskReadV2(BaseModel):
 
     id: int
     name: str
     type: Literal["parallel", "non_parallel", "compound"]
-    source: str
-    owner: Optional[str]
-    version: Optional[str]
+    source: Optional[str] = None
+    version: Optional[str] = None
 
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
     meta_parallel: dict[str, Any]
     meta_non_parallel: dict[str, Any]
     args_schema_non_parallel: Optional[dict[str, Any]] = None
     args_schema_parallel: Optional[dict[str, Any]] = None
-    args_schema_version: Optional[str]
-    docs_info: Optional[str]
-    docs_link: Optional[HttpUrl]
+    args_schema_version: Optional[str] = None
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
     input_types: dict[str, bool]
     output_types: dict[str, bool]
 
+    taskgroupv2_id: Optional[int] = None
+
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: list[str]
+
 
-class TaskUpdateV2(BaseModel):
+class TaskUpdateV2(BaseModel, extra=Extra.forbid):
 
-    name: Optional[str]
-    version: Optional[str]
-    command_parallel: Optional[str]
-    command_non_parallel: Optional[str]
-    input_types: Optional[dict[str, bool]]
-    output_types: Optional[dict[str, bool]]
+    command_parallel: Optional[str] = None
+    command_non_parallel: Optional[str] = None
+    input_types: Optional[dict[str, bool]] = None
+    output_types: Optional[dict[str, bool]] = None
+
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: Optional[list[str]] = None
 
     # Validators
     @validator("input_types", "output_types")
@@ -122,10 +151,6 @@ class TaskUpdateV2(BaseModel):
             raise ValueError
         return v
 
-    _name = validator("name", allow_reuse=True)(valstr("name"))
-    _version = validator("version", allow_reuse=True)(
-        valstr("version", accept_none=True)
-    )
     _command_parallel = validator("command_parallel", allow_reuse=True)(
         valstr("command_parallel")
     )
@@ -139,14 +164,48 @@ class TaskUpdateV2(BaseModel):
         valdictkeys("output_types")
     )
 
+    _category = validator("category", allow_reuse=True)(
+        valstr("category", accept_none=True)
+    )
+    _modality = validator("modality", allow_reuse=True)(
+        valstr("modality", accept_none=True)
+    )
+    _authors = validator("authors", allow_reuse=True)(
+        valstr("authors", accept_none=True)
+    )
+
+    @validator("tags")
+    def validate_tags(cls, value):
+        for i, tag in enumerate(value):
+            value[i] = valstr(f"tags[{i}]")(tag)
+        return val_unique_list("tags")(value)
+
+
+class TaskImportV2(BaseModel, extra=Extra.forbid):
 
-class TaskImportV2(BaseModel):
+    pkg_name: str
+    version: Optional[str] = None
+    name: str
+    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
+    _version = validator("version", allow_reuse=True)(
+        valstr("version", accept_none=True)
+    )
+    _name = validator("name", allow_reuse=True)(valstr("name"))
 
+
+class TaskImportV2Legacy(BaseModel):
     source: str
     _source = validator("source", allow_reuse=True)(valstr("source"))
 
 
 class TaskExportV2(BaseModel):
 
-    source: str
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    pkg_name: str
+    version: Optional[str] = None
+    name: str
+
+    _pkg_name = validator("pkg_name", allow_reuse=True)(valstr("pkg_name"))
+    _version = validator("version", allow_reuse=True)(
+        valstr("version", accept_none=True)
+    )
+    _name = validator("name", allow_reuse=True)(valstr("name"))

fractal_server/app/schemas/v2/task_collection.py

@@ -6,6 +6,7 @@ from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
+from pydantic import Extra
 from pydantic import root_validator
 from pydantic import validator
 
@@ -24,7 +25,7 @@ class CollectionStatusV2(str, Enum):
     OK = "OK"
 
 
-class TaskCollectPipV2(BaseModel):
+class TaskCollectPipV2(BaseModel, extra=Extra.forbid):
     """
     TaskCollectPipV2 class
 
@@ -70,7 +71,7 @@ class TaskCollectPipV2(BaseModel):
 
     @validator("package")
     def package_validator(cls, value):
-        if "/" in value:
+        if "/" in value or value.endswith(".whl"):
             if not value.endswith(".whl"):
                 raise ValueError(
                     "Local-package path must be a wheel file "
@@ -92,14 +93,15 @@ class TaskCollectPipV2(BaseModel):
         return v
 
 
-class TaskCollectCustomV2(BaseModel):
+class TaskCollectCustomV2(BaseModel, extra=Extra.forbid):
     """
     Attributes:
         manifest: Manifest of a Fractal task package (this is typically the
             content of `__FRACTAL_MANIFEST__.json`).
         python_interpreter: Absolute path to the Python interpreter to be used
             for running tasks.
-        source: A common label identifying this package.
+        name: A name identifying this package, that will fill the
+            `TaskGroupV2.pkg_name` column.
         package_root: The folder where the package is installed.
             If not provided, it will be extracted via `pip show`
             (requires `package_name` to be set).
@@ -111,7 +113,7 @@ class TaskCollectCustomV2(BaseModel):
 
     manifest: ManifestV2
     python_interpreter: str
-    source: str
+    label: str
     package_root: Optional[str]
     package_name: Optional[str]
     version: Optional[str]
@@ -120,7 +122,7 @@ class TaskCollectCustomV2(BaseModel):
     _python_interpreter = validator("python_interpreter", allow_reuse=True)(
         valstr("python_interpreter")
     )
-    _source = validator("source", allow_reuse=True)(valstr("source"))
+    _label = validator("label", allow_reuse=True)(valstr("label"))
     _package_root = validator("package_root", allow_reuse=True)(
         valstr("package_root", accept_none=True)
     )

fractal_server/app/schemas/v2/task_group.py

@@ -0,0 +1,85 @@
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Extra
+from pydantic import Field
+from pydantic import validator
+
+from .._validators import val_absolute_path
+from .._validators import valdictkeys
+from .._validators import valstr
+from .task import TaskReadV2
+
+
+class TaskGroupV2OriginEnum(str, Enum):
+    PYPI = "pypi"
+    WHEELFILE = "wheel-file"
+    OTHER = "other"
+
+
+class TaskGroupCreateV2(BaseModel, extra=Extra.forbid):
+    user_id: int
+    user_group_id: Optional[int] = None
+    active: bool = True
+    origin: TaskGroupV2OriginEnum
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    venv_path: Optional[str] = None
+    wheel_path: Optional[str] = None
+    pip_extras: Optional[str] = None
+    pinned_package_versions: dict[str, str] = Field(default_factory=dict)
+
+    # Validators
+    _path = validator("path", allow_reuse=True)(val_absolute_path("path"))
+    _venv_path = validator("venv_path", allow_reuse=True)(
+        val_absolute_path("venv_path")
+    )
+    _wheel_path = validator("wheel_path", allow_reuse=True)(
+        val_absolute_path("wheel_path")
+    )
+    _pinned_package_versions = validator(
+        "pinned_package_versions", allow_reuse=True
+    )(valdictkeys("pinned_package_versions"))
+    _pip_extras = validator("pip_extras", allow_reuse=True)(
+        valstr("pip_extras")
+    )
+    _python_version = validator("python_version", allow_reuse=True)(
+        valstr("python_version")
+    )
+
+
+class TaskGroupReadV2(BaseModel):
+    id: int
+    task_list: list[TaskReadV2]
+
+    user_id: int
+    user_group_id: Optional[int] = None
+
+    origin: Literal["pypi", "wheel-file", "other"]
+    pkg_name: str
+    version: Optional[str] = None
+    python_version: Optional[str] = None
+    path: Optional[str] = None
+    venv_path: Optional[str] = None
+    wheel_path: Optional[str] = None
+    pip_extras: Optional[str] = None
+    pinned_package_versions: dict[str, str] = Field(default_factory=dict)
+
+    active: bool
+    timestamp_created: datetime
+
+
+class TaskGroupUpdateV2(BaseModel, extra=Extra.forbid):
+    user_group_id: Optional[int] = None
+    active: Optional[bool] = None
+
+    @validator("active")
+    def active_cannot_be_None(cls, value):
+        if value is None:
+            raise ValueError("`active` cannot be set to None")
+        return value

fractal_server/app/schemas/v2/workflow.py

@@ -11,6 +11,7 @@ from .project import ProjectReadV2
 from .workflowtask import WorkflowTaskExportV2
 from .workflowtask import WorkflowTaskImportV2
 from .workflowtask import WorkflowTaskReadV2
+from .workflowtask import WorkflowTaskReadV2WithWarning
 
 
 class WorkflowCreateV2(BaseModel, extra=Extra.forbid):
@@ -35,7 +36,11 @@ class WorkflowReadV2(BaseModel):
     )
 
 
-class WorkflowUpdateV2(BaseModel):
+class WorkflowReadV2WithWarnings(WorkflowReadV2):
+    task_list: list[WorkflowTaskReadV2WithWarning]
+
+
+class WorkflowUpdateV2(BaseModel, extra=Extra.forbid):
 
     name: Optional[str]
     reordered_workflowtask_ids: Optional[list[int]]
@@ -52,7 +57,7 @@ class WorkflowUpdateV2(BaseModel):
         return value
 
 
-class WorkflowImportV2(BaseModel):
+class WorkflowImportV2(BaseModel, extra=Extra.forbid):
     """
     Class for `Workflow` import.
 

fractal_server/app/schemas/v2/workflowtask.py

@@ -1,6 +1,7 @@
 from enum import Enum
 from typing import Any
 from typing import Optional
+from typing import Union
 
 from pydantic import BaseModel
 from pydantic import Extra
@@ -8,9 +9,9 @@ from pydantic import Field
 from pydantic import validator
 
 from .._validators import valdictkeys
-from .._validators import valint
 from .task import TaskExportV2
 from .task import TaskImportV2
+from .task import TaskImportV2Legacy
 from .task import TaskReadV2
 from fractal_server.images import Filters
 
@@ -42,7 +43,6 @@ class WorkflowTaskCreateV2(BaseModel, extra=Extra.forbid):
     meta_parallel: Optional[dict[str, Any]]
     args_non_parallel: Optional[dict[str, Any]]
     args_parallel: Optional[dict[str, Any]]
-    order: Optional[int]
     input_filters: Filters = Field(default_factory=Filters)
 
     # Validators
@@ -52,7 +52,6 @@ class WorkflowTaskCreateV2(BaseModel, extra=Extra.forbid):
     _meta_parallel = validator("meta_parallel", allow_reuse=True)(
         valdictkeys("meta_parallel")
     )
-    _order = validator("order", allow_reuse=True)(valint("order", min_val=0))
 
     @validator("args_non_parallel")
     def validate_args_non_parallel(cls, value):
@@ -102,7 +101,11 @@ class WorkflowTaskReadV2(BaseModel):
     task: TaskReadV2
 
 
-class WorkflowTaskUpdateV2(BaseModel):
+class WorkflowTaskReadV2WithWarning(WorkflowTaskReadV2):
+    warning: Optional[str] = None
+
+
+class WorkflowTaskUpdateV2(BaseModel, extra=Extra.forbid):
 
     meta_non_parallel: Optional[dict[str, Any]]
     meta_parallel: Optional[dict[str, Any]]
@@ -147,7 +150,7 @@ class WorkflowTaskUpdateV2(BaseModel):
         return value
 
 
-class WorkflowTaskImportV2(BaseModel):
+class WorkflowTaskImportV2(BaseModel, extra=Extra.forbid):
 
     meta_non_parallel: Optional[dict[str, Any]] = None
     meta_parallel: Optional[dict[str, Any]] = None
@@ -156,7 +159,7 @@ class WorkflowTaskImportV2(BaseModel):
 
     input_filters: Optional[Filters] = None
 
-    task: TaskImportV2
+    task: Union[TaskImportV2, TaskImportV2Legacy]
 
     _meta_non_parallel = validator("meta_non_parallel", allow_reuse=True)(
         valdictkeys("meta_non_parallel")

fractal_server/app/security/__init__.py

@@ -315,13 +315,20 @@ async def _create_first_user(
 
 
 def _create_first_group():
+    """
+    Create a `UserGroup` with `name=FRACTAL_DEFAULT_GROUP_NAME`, if missing.
+    """
     function_logger = set_logger("fractal_server.create_first_group")
 
     function_logger.info(
         f"START _create_first_group, with name '{FRACTAL_DEFAULT_GROUP_NAME}'"
     )
     with next(get_sync_db()) as db:
-        group_all = db.execute(select(UserGroup))
+        group_all = db.execute(
+            select(UserGroup).where(
+                UserGroup.name == FRACTAL_DEFAULT_GROUP_NAME
+            )
+        )
         if group_all.scalars().one_or_none() is None:
             first_group = UserGroup(name=FRACTAL_DEFAULT_GROUP_NAME)
             db.add(first_group)

fractal_server/config.py

@@ -167,9 +167,9 @@ class Settings(BaseSettings):
     ###########################################################################
     # DATABASE
     ###########################################################################
-    DB_ENGINE: Literal["sqlite", "postgres", "postgres-psycopg"] = "sqlite"
+    DB_ENGINE: Literal["sqlite", "postgres-psycopg"] = "sqlite"
     """
-    Select which database engine to use (supported: `sqlite` and `postgres`).
+    Database engine to use (supported: `sqlite`, `postgres-psycopg`).
     """
     DB_ECHO: bool = False
     """
@@ -203,16 +203,7 @@ class Settings(BaseSettings):
 
     @property
     def DATABASE_ASYNC_URL(self) -> URL:
-        if self.DB_ENGINE == "postgres":
-            url = URL.create(
-                drivername="postgresql+asyncpg",
-                username=self.POSTGRES_USER,
-                password=self.POSTGRES_PASSWORD,
-                host=self.POSTGRES_HOST,
-                port=self.POSTGRES_PORT,
-                database=self.POSTGRES_DB,
-            )
-        elif self.DB_ENGINE == "postgres-psycopg":
+        if self.DB_ENGINE == "postgres-psycopg":
             url = URL.create(
                 drivername="postgresql+psycopg",
                 username=self.POSTGRES_USER,
@@ -235,11 +226,7 @@ class Settings(BaseSettings):
 
     @property
     def DATABASE_SYNC_URL(self):
-        if self.DB_ENGINE == "postgres":
-            return self.DATABASE_ASYNC_URL.set(
-                drivername="postgresql+psycopg2"
-            )
-        elif self.DB_ENGINE == "postgres-psycopg":
+        if self.DB_ENGINE == "postgres-psycopg":
             return self.DATABASE_ASYNC_URL.set(drivername="postgresql+psycopg")
         else:
             if not self.SQLITE_PATH:
@@ -546,20 +533,13 @@ class Settings(BaseSettings):
         """
         Checks that db environment variables are properly set.
         """
-        if self.DB_ENGINE == "postgres":
+        if self.DB_ENGINE == "postgres-psycopg":
             if not self.POSTGRES_DB:
                 raise FractalConfigurationError(
-                    "POSTGRES_DB cannot be None when DB_ENGINE=postgres."
-                )
-            try:
-                import psycopg2  # noqa: F401
-                import asyncpg  # noqa: F401
-            except ModuleNotFoundError:
-                raise FractalConfigurationError(
-                    "DB engine is `postgres` but `psycopg2` or `asyncpg` "
-                    "are not available"
+                    "POSTGRES_DB cannot be None when DB_ENGINE="
+                    "postgres-psycopg."
                 )
-        elif self.DB_ENGINE == "postgres-psycopg":
+
             try:
                 import psycopg  # noqa: F401
             except ModuleNotFoundError: