fractal-server 2.6.3__tar.gz → 2.7.0__tar.gz

{fractal_server-2.6.3 → fractal_server-2.7.0}/PKG-INFO

@@ -1,34 +1,30 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.6.3
+Version: 2.7.0
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause
 Author: Tommaso Comparin
 Author-email: tommaso.comparin@exact-lab.it
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: gunicorn
-Provides-Extra: postgres
 Provides-Extra: postgres-psycopg-binary
 Requires-Dist: aiosqlite (>=0.19.0,<0.20.0)
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
-Requires-Dist: asyncpg (>=0.29.0,<0.30.0) ; extra == "postgres"
 Requires-Dist: bcrypt (==4.0.1)
 Requires-Dist: cloudpickle (>=3.0.0,<3.1.0)
 Requires-Dist: clusterfutures (>=0.5,<0.6)
 Requires-Dist: fabric (>=3.2.2,<4.0.0)
-Requires-Dist: fastapi (>=0.112.0,<0.113.0)
+Requires-Dist: fastapi (>=0.115.0,<0.116.0)
 Requires-Dist: fastapi-users[oauth] (>=12.1.0,<13.0.0)
 Requires-Dist: gunicorn (>=21.2,<23.0) ; extra == "gunicorn"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: psutil (>=5.9.8,<6.0.0)
-Requires-Dist: psycopg2 (>=2.9.5,<3.0.0) ; extra == "postgres"
 Requires-Dist: psycopg[binary] (>=3.1.0,<4.0.0) ; extra == "postgres-psycopg-binary"
 Requires-Dist: pydantic (>=1.10.8,<2)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)

fractal_server-2.7.0/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.7.0"

{fractal_server-2.6.3 → fractal_server-2.7.0}/fractal_server/__main__.py

@@ -57,7 +57,7 @@ set_db_parser.add_argument(
 )
 
 # fractalctl update-db-data
-subparsers.add_parser(
+update_db_data_parser = subparsers.add_parser(
     "update-db-data",
     description="Apply data-migration script to an existing database.",
 )

{fractal_server-2.6.3 → fractal_server-2.7.0}/fractal_server/app/models/linkusergroup.py

@@ -1,6 +1,12 @@
+from datetime import datetime
+
+from sqlalchemy import Column
+from sqlalchemy.types import DateTime
 from sqlmodel import Field
 from sqlmodel import SQLModel
 
+from fractal_server.utils import get_timestamp
+
 
 class LinkUserGroup(SQLModel, table=True):
     """
@@ -9,3 +15,8 @@ class LinkUserGroup(SQLModel, table=True):
 
     group_id: int = Field(foreign_key="usergroup.id", primary_key=True)
     user_id: int = Field(foreign_key="user_oauth.id", primary_key=True)
+
+    timestamp_created: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )

{fractal_server-2.6.3 → fractal_server-2.7.0}/fractal_server/app/models/v2/__init__.py

@@ -6,6 +6,7 @@ from .collection_state import CollectionStateV2
 from .dataset import DatasetV2
 from .job import JobV2
 from .project import ProjectV2
+from .task import TaskGroupV2
 from .task import TaskV2
 from .workflow import WorkflowV2
 from .workflowtask import WorkflowTaskV2
@@ -16,6 +17,7 @@ __all__ = [
     "JobV2",
     "ProjectV2",
     "CollectionStateV2",
+    "TaskGroupV2",
     "TaskV2",
     "WorkflowTaskV2",
     "WorkflowV2",

{fractal_server-2.6.3 → fractal_server-2.7.0}/fractal_server/app/models/v2/collection_state.py

@@ -14,6 +14,7 @@ from ....utils import get_timestamp
 class CollectionStateV2(SQLModel, table=True):
 
     id: Optional[int] = Field(default=None, primary_key=True)
+    taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
     data: dict[str, Any] = Field(sa_column=Column(JSON), default={})
     timestamp: datetime = Field(
         default_factory=get_timestamp,

fractal_server-2.7.0/fractal_server/app/models/v2/task.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+from typing import Any
+from typing import Optional
+
+from pydantic import HttpUrl
+from sqlalchemy import Column
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import JSON
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+from fractal_server.utils import get_timestamp
+
+
+class TaskV2(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str
+
+    type: str
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str] = None
+    source: Optional[str] = None
+
+    meta_non_parallel: dict[str, Any] = Field(
+        sa_column=Column(JSON, server_default="{}", default={}, nullable=False)
+    )
+    meta_parallel: dict[str, Any] = Field(
+        sa_column=Column(JSON, server_default="{}", default={}, nullable=False)
+    )
+
+    owner: Optional[str] = None
+    version: Optional[str] = None
+    args_schema_non_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
+    args_schema_parallel: Optional[dict[str, Any]] = Field(
+        sa_column=Column(JSON), default=None
+    )
+    args_schema_version: Optional[str]
+    docs_info: Optional[str] = None
+    docs_link: Optional[HttpUrl] = None
+
+    input_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})
+    output_types: dict[str, bool] = Field(sa_column=Column(JSON), default={})
+
+    taskgroupv2_id: Optional[int] = Field(foreign_key="taskgroupv2.id")
+
+    category: Optional[str] = None
+    modality: Optional[str] = None
+    authors: Optional[str] = None
+    tags: list[str] = Field(
+        sa_column=Column(JSON, server_default="[]", nullable=False)
+    )
+
+
+class TaskGroupV2(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    task_list: list[TaskV2] = Relationship(
+        sa_relationship_kwargs=dict(
+            lazy="selectin", cascade="all, delete-orphan"
+        ),
+    )
+
+    user_id: int = Field(foreign_key="user_oauth.id")
+    user_group_id: Optional[int] = Field(foreign_key="usergroup.id")
+
+    origin: str
+    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(
+        sa_column=Column(
+            JSON,
+            server_default="{}",
+            default={},
+            nullable=True,
+        ),
+    )
+
+    active: bool = True
+    timestamp_created: datetime = Field(
+        default_factory=get_timestamp,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
+
+    @property
+    def pip_install_string(self) -> str:
+        """
+        Prepare string to be used in `python -m pip install`.
+        """
+        extras = f"[{self.pip_extras}]" if self.pip_extras is not None else ""
+
+        if self.wheel_path is not None:
+            return f"{self.wheel_path}{extras}"
+        else:
+            if self.version is None:
+                raise ValueError(
+                    "Cannot run `pip_install_string` with "
+                    f"{self.pkg_name=}, {self.wheel_path=}, {self.version=}."
+                )
+            return f"{self.pkg_name}{extras}=={self.version}"

fractal_server-2.7.0/fractal_server/app/routes/admin/v2/__init__.py

@@ -0,0 +1,16 @@
+"""
+`admin/v2` module
+"""
+from fastapi import APIRouter
+
+from .job import router as job_router
+from .project import router as project_router
+from .task import router as task_router
+from .task_group import router as task_group_router
+
+router_admin_v2 = APIRouter()
+
+router_admin_v2.include_router(job_router, prefix="/job")
+router_admin_v2.include_router(project_router, prefix="/project")
+router_admin_v2.include_router(task_router, prefix="/task")
+router_admin_v2.include_router(task_group_router, prefix="/task-group")

fractal_server-2.6.3/fractal_server/app/routes/admin/v2.py → fractal_server-2.7.0/fractal_server/app/routes/admin/v2/job.py

@@ -1,10 +1,6 @@
-"""
-Definition of `/admin` routes.
-"""
 from datetime import datetime
 from datetime import timezone
 from pathlib import Path
-from typing import Literal
 from typing import Optional
 
 from fastapi import APIRouter
@@ -13,33 +9,26 @@ from fastapi import HTTPException
 from fastapi import Response
 from fastapi import status
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-from pydantic import EmailStr
-from pydantic import Field
 from sqlmodel import select
 
-from ....config import get_settings
-from ....syringe import Inject
-from ....utils import get_timestamp
-from ....zip_tools import _zip_folder_to_byte_stream_iterator
-from ...db import AsyncSession
-from ...db import get_async_db
-from ...models.v2 import JobV2
-from ...models.v2 import ProjectV2
-from ...models.v2 import TaskV2
-from ...models.v2 import WorkflowTaskV2
-from ...models.v2 import WorkflowV2
-from ...runner.filenames import WORKFLOW_LOG_FILENAME
-from ...schemas.v2 import JobReadV2
-from ...schemas.v2 import JobStatusTypeV2
-from ...schemas.v2 import JobUpdateV2
-from ...schemas.v2 import ProjectReadV2
-from ..aux._job import _write_shutdown_file
-from ..aux._runner import _check_shutdown_is_supported
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import JobV2
+from fractal_server.app.models.v2 import ProjectV2
 from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.routes.aux._job import _write_shutdown_file
+from fractal_server.app.routes.aux._runner import _check_shutdown_is_supported
+from fractal_server.app.runner.filenames import WORKFLOW_LOG_FILENAME
+from fractal_server.app.schemas.v2 import JobReadV2
+from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.app.schemas.v2 import JobUpdateV2
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+from fractal_server.utils import get_timestamp
+from fractal_server.zip_tools import _zip_folder_to_byte_stream_iterator
 
-router_admin_v2 = APIRouter()
+router = APIRouter()
 
 
 def _convert_to_db_timestamp(dt: datetime) -> datetime:
@@ -59,36 +48,7 @@ def _convert_to_db_timestamp(dt: datetime) -> datetime:
     return _dt
 
 
-@router_admin_v2.get("/project/", response_model=list[ProjectReadV2])
-async def view_project(
-    id: Optional[int] = None,
-    user_id: Optional[int] = None,
-    user: UserOAuth = Depends(current_active_superuser),
-    db: AsyncSession = Depends(get_async_db),
-) -> list[ProjectReadV2]:
-    """
-    Query `ProjectV2` table.
-
-    Args:
-        id: If not `None`, select a given `project.id`.
-        user_id: If not `None`, select a given `project.user_id`.
-    """
-
-    stm = select(ProjectV2)
-
-    if id is not None:
-        stm = stm.where(ProjectV2.id == id)
-    if user_id is not None:
-        stm = stm.where(ProjectV2.user_list.any(UserOAuth.id == user_id))
-
-    res = await db.execute(stm)
-    project_list = res.scalars().all()
-    await db.close()
-
-    return project_list
-
-
-@router_admin_v2.get("/job/", response_model=list[JobReadV2])
+@router.get("/", response_model=list[JobReadV2])
 async def view_job(
     id: Optional[int] = None,
     user_id: Optional[int] = None,
@@ -164,7 +124,7 @@ async def view_job(
     return job_list
 
 
-@router_admin_v2.get("/job/{job_id}/", response_model=JobReadV2)
+@router.get("/{job_id}/", response_model=JobReadV2)
 async def view_single_job(
     job_id: int = None,
     show_tmp_logs: bool = False,
@@ -190,10 +150,7 @@ async def view_single_job(
     return job
 
 
-@router_admin_v2.patch(
-    "/job/{job_id}/",
-    response_model=JobReadV2,
-)
+@router.patch("/{job_id}/", response_model=JobReadV2)
 async def update_job(
     job_update: JobUpdateV2,
     job_id: int,
@@ -227,7 +184,7 @@ async def update_job(
     return job
 
 
-@router_admin_v2.get("/job/{job_id}/stop/", status_code=202)
+@router.get("/{job_id}/stop/", status_code=202)
 async def stop_job(
     job_id: int,
     user: UserOAuth = Depends(current_active_superuser),
@@ -251,10 +208,7 @@ async def stop_job(
     return Response(status_code=status.HTTP_202_ACCEPTED)
 
 
-@router_admin_v2.get(
-    "/job/{job_id}/download/",
-    response_class=StreamingResponse,
-)
+@router.get("/{job_id}/download/", response_class=StreamingResponse)
 async def download_job_logs(
     job_id: int,
     user: UserOAuth = Depends(current_active_superuser),
@@ -278,128 +232,3 @@ async def download_job_logs(
         media_type="application/x-zip-compressed",
         headers={"Content-Disposition": f"attachment;filename={zip_filename}"},
     )
-
-
-class TaskV2Minimal(BaseModel):
-
-    id: int
-    name: str
-    type: str
-    command_non_parallel: Optional[str]
-    command_parallel: Optional[str]
-    source: str
-    owner: Optional[str]
-    version: Optional[str]
-
-
-class ProjectUser(BaseModel):
-
-    id: int
-    email: EmailStr
-
-
-class TaskV2Relationship(BaseModel):
-
-    workflow_id: int
-    workflow_name: str
-    project_id: int
-    project_name: str
-    project_users: list[ProjectUser] = Field(default_factory=list)
-
-
-class TaskV2Info(BaseModel):
-
-    task: TaskV2Minimal
-    relationships: list[TaskV2Relationship]
-
-
-@router_admin_v2.get("/task/", response_model=list[TaskV2Info])
-async def query_tasks(
-    id: Optional[int] = None,
-    source: Optional[str] = None,
-    version: Optional[str] = None,
-    name: Optional[str] = None,
-    owner: Optional[str] = None,
-    kind: Optional[Literal["common", "users"]] = None,
-    max_number_of_results: int = 25,
-    user: UserOAuth = Depends(current_active_superuser),
-    db: AsyncSession = Depends(get_async_db),
-) -> list[TaskV2Info]:
-    """
-    Query `TaskV2` table and get informations about related items
-    (WorkflowV2s and ProjectV2s)
-
-    Args:
-        id: If not `None`, query for matching `task.id`.
-        source: If not `None`, query for contained case insensitive
-            `task.source`.
-        version: If not `None`, query for matching `task.version`.
-        name: If not `None`, query for contained case insensitive `task.name`.
-        owner: If not `None`, query for matching `task.owner`.
-        kind: If not `None`, query for TaskV2s that have (`users`) or don't
-            have (`common`) a `task.owner`.
-        max_number_of_results: The maximum length of the response.
-    """
-
-    stm = select(TaskV2)
-
-    if id is not None:
-        stm = stm.where(TaskV2.id == id)
-    if source is not None:
-        stm = stm.where(TaskV2.source.icontains(source))
-    if version is not None:
-        stm = stm.where(TaskV2.version == version)
-    if name is not None:
-        stm = stm.where(TaskV2.name.icontains(name))
-    if owner is not None:
-        stm = stm.where(TaskV2.owner == owner)
-
-    if kind == "common":
-        stm = stm.where(TaskV2.owner == None)  # noqa E711
-    elif kind == "users":
-        stm = stm.where(TaskV2.owner != None)  # noqa E711
-
-    res = await db.execute(stm)
-    task_list = res.scalars().all()
-    if len(task_list) > max_number_of_results:
-        await db.close()
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                f"Too many Tasks ({len(task_list)} > {max_number_of_results})."
-                " Please add more query filters."
-            ),
-        )
-
-    task_info_list = []
-
-    for task in task_list:
-        stm = (
-            select(WorkflowV2)
-            .join(WorkflowTaskV2)
-            .where(WorkflowTaskV2.workflow_id == WorkflowV2.id)
-            .where(WorkflowTaskV2.task_id == task.id)
-        )
-        res = await db.execute(stm)
-        wf_list = res.scalars().all()
-
-        task_info_list.append(
-            dict(
-                task=task.model_dump(),
-                relationships=[
-                    dict(
-                        workflow_id=workflow.id,
-                        workflow_name=workflow.name,
-                        project_id=workflow.project.id,
-                        project_name=workflow.project.name,
-                        project_users=[
-                            dict(id=user.id, email=user.email)
-                            for user in workflow.project.user_list
-                        ],
-                    )
-                    for workflow in wf_list
-                ],
-            )
-        )
-
-    return task_info_list

fractal_server-2.7.0/fractal_server/app/routes/admin/v2/project.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import ProjectV2
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.schemas.v2 import ProjectReadV2
+
+router = APIRouter()
+
+
+@router.get("/", response_model=list[ProjectReadV2])
+async def view_project(
+    id: Optional[int] = None,
+    user_id: Optional[int] = None,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ProjectReadV2]:
+    """
+    Query `ProjectV2` table.
+
+    Args:
+        id: If not `None`, select a given `project.id`.
+        user_id: If not `None`, select a given `project.user_id`.
+    """
+
+    stm = select(ProjectV2)
+
+    if id is not None:
+        stm = stm.where(ProjectV2.id == id)
+    if user_id is not None:
+        stm = stm.where(ProjectV2.user_list.any(UserOAuth.id == user_id))
+
+    res = await db.execute(stm)
+    project_list = res.scalars().all()
+    await db.close()
+
+    return project_list

fractal_server-2.7.0/fractal_server/app/routes/admin/v2/task.py

@@ -0,0 +1,133 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import status
+from pydantic import BaseModel
+from pydantic import EmailStr
+from pydantic import Field
+from sqlmodel import select
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import TaskV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.models.v2 import WorkflowV2
+from fractal_server.app.routes.auth import current_active_superuser
+
+router = APIRouter()
+
+
+class TaskV2Minimal(BaseModel):
+
+    id: int
+    name: str
+    type: str
+    taskgroupv2_id: int
+    command_non_parallel: Optional[str] = None
+    command_parallel: Optional[str]
+    source: Optional[str] = None
+    version: Optional[str] = None
+
+
+class ProjectUser(BaseModel):
+
+    id: int
+    email: EmailStr
+
+
+class TaskV2Relationship(BaseModel):
+
+    workflow_id: int
+    workflow_name: str
+    project_id: int
+    project_name: str
+    project_users: list[ProjectUser] = Field(default_factory=list)
+
+
+class TaskV2Info(BaseModel):
+
+    task: TaskV2Minimal
+    relationships: list[TaskV2Relationship]
+
+
+@router.get("/", response_model=list[TaskV2Info])
+async def query_tasks(
+    id: Optional[int] = None,
+    source: Optional[str] = None,
+    version: Optional[str] = None,
+    name: Optional[str] = None,
+    max_number_of_results: int = 25,
+    user: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskV2Info]:
+    """
+    Query `TaskV2` table and get informations about related items
+    (WorkflowV2s and ProjectV2s)
+
+    Args:
+        id: If not `None`, query for matching `task.id`.
+        source: If not `None`, query for contained case insensitive
+            `task.source`.
+        version: If not `None`, query for matching `task.version`.
+        name: If not `None`, query for contained case insensitive `task.name`.
+        max_number_of_results: The maximum length of the response.
+    """
+
+    stm = select(TaskV2)
+
+    if id is not None:
+        stm = stm.where(TaskV2.id == id)
+    if source is not None:
+        stm = stm.where(TaskV2.source.icontains(source))
+    if version is not None:
+        stm = stm.where(TaskV2.version == version)
+    if name is not None:
+        stm = stm.where(TaskV2.name.icontains(name))
+
+    res = await db.execute(stm)
+    task_list = res.scalars().all()
+    if len(task_list) > max_number_of_results:
+        await db.close()
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Too many Tasks ({len(task_list)} > {max_number_of_results})."
+                " Please add more query filters."
+            ),
+        )
+
+    task_info_list = []
+
+    for task in task_list:
+        stm = (
+            select(WorkflowV2)
+            .join(WorkflowTaskV2)
+            .where(WorkflowTaskV2.workflow_id == WorkflowV2.id)
+            .where(WorkflowTaskV2.task_id == task.id)
+        )
+        res = await db.execute(stm)
+        wf_list = res.scalars().all()
+
+        task_info_list.append(
+            dict(
+                task=task.model_dump(),
+                relationships=[
+                    dict(
+                        workflow_id=workflow.id,
+                        workflow_name=workflow.name,
+                        project_id=workflow.project.id,
+                        project_name=workflow.project.name,
+                        project_users=[
+                            dict(id=user.id, email=user.email)
+                            for user in workflow.project.user_list
+                        ],
+                    )
+                    for workflow in wf_list
+                ],
+            )
+        )
+
+    return task_info_list