fractal-server 2.7.0a4__tar.gz → 2.7.0a5__tar.gz

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.7.0a4
+Version: 2.7.0a5
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause

fractal_server-2.7.0a5/fractal_server/__init__.py

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

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/admin/v2/task.py

@@ -29,7 +29,6 @@ class TaskV2Minimal(BaseModel):
     command_non_parallel: Optional[str] = None
     command_parallel: Optional[str]
     source: Optional[str] = None
-    owner: Optional[str] = None
     version: Optional[str] = None
 
 
@@ -60,7 +59,6 @@ async def query_tasks(
     source: Optional[str] = None,
     version: Optional[str] = None,
     name: Optional[str] = None,
-    owner: Optional[str] = None,
     max_number_of_results: int = 25,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
@@ -75,7 +73,6 @@ async def query_tasks(
             `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`.
         max_number_of_results: The maximum length of the response.
     """
 
@@ -89,8 +86,6 @@ async def query_tasks(
         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)
 
     res = await db.execute(stm)
     task_list = res.scalars().all()

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/api/v1/task_collection.py

@@ -27,7 +27,7 @@ from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.routes.auth import current_active_verified_user
 from fractal_server.string_tools import slugify_task_name_for_source_v1
-from fractal_server.tasks.utils import get_collection_log
+from fractal_server.tasks.utils import get_collection_log_v1
 from fractal_server.tasks.v1._TaskCollectPip import _TaskCollectPip
 from fractal_server.tasks.v1.background_operations import (
     background_collect_pip,
@@ -232,7 +232,7 @@ async def check_collection_status(
     # In some cases (i.e. a successful or ongoing task collection), data.log is
     # not set; if so, we collect the current logs
     if verbose and not data.log:
-        data.log = get_collection_log(data.venv_path)
+        data.log = get_collection_log_v1(data.venv_path)
         state.data = data.sanitised_dict()
     close_logger(logger)
     await db.close()

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/api/v2/_aux_functions.py

@@ -332,7 +332,6 @@ async def _workflow_insert_task(
     *,
     workflow_id: int,
     task_id: int,
-    order: Optional[int] = None,
     meta_parallel: Optional[dict[str, Any]] = None,
     meta_non_parallel: Optional[dict[str, Any]] = None,
     args_non_parallel: Optional[dict[str, Any]] = None,
@@ -347,7 +346,6 @@ async def _workflow_insert_task(
         workflow_id:
         task_id:
 
-        order:
         meta_parallel:
         meta_non_parallel:
         args_non_parallel:
@@ -359,9 +357,6 @@ async def _workflow_insert_task(
     if db_workflow is None:
         raise ValueError(f"Workflow {workflow_id} does not exist")
 
-    if order is None:
-        order = len(db_workflow.task_list)
-
     # Get task from db
     db_task = await db.get(TaskV2, task_id)
     if db_task is None:
@@ -397,8 +392,7 @@ async def _workflow_insert_task(
         meta_non_parallel=final_meta_non_parallel,
         **input_filters_kwarg,
     )
-    db_workflow.task_list.insert(order, wf_task)
-    db_workflow.task_list.reorder()  # type: ignore
+    db_workflow.task_list.append(wf_task)
     flag_modified(db_workflow, "task_list")
     await db.commit()
 

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/api/v2/task_collection.py

@@ -31,7 +31,7 @@ from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_user
 from fractal_server.app.routes.auth import current_active_verified_user
 from fractal_server.tasks.utils import _normalize_package_name
-from fractal_server.tasks.utils import get_collection_log
+from fractal_server.tasks.utils import get_collection_log_v2
 from fractal_server.tasks.v2.background_operations import (
     background_collect_pip,
 )
@@ -70,33 +70,40 @@ async def collect_tasks_pip(
     # Get settings
     settings = Inject(get_settings)
 
+    # Initialize task-group attributes
+    task_group_attrs = dict(user_id=user.id)
+
     # Set/check python version
     if task_collect.python_version is None:
-        task_collect.python_version = (
-            settings.FRACTAL_TASKS_PYTHON_DEFAULT_VERSION
-        )
+        task_group_attrs[
+            "python_version"
+        ] = settings.FRACTAL_TASKS_PYTHON_DEFAULT_VERSION
+    else:
+        task_group_attrs["python_version"] = task_collect.python_version
     try:
-        get_python_interpreter_v2(python_version=task_collect.python_version)
+        get_python_interpreter_v2(
+            python_version=task_group_attrs["python_version"]
+        )
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
-                f"Python version {task_collect.python_version} is "
+                f"Python version {task_group_attrs['python_version']} is "
                 "not available for Fractal task collection."
             ),
         )
 
-    # Populate task-group attributes
-    task_group_attrs = dict(
-        user_id=user.id,
-        python_version=task_collect.python_version,
-    )
+    # Set pip_extras
     if task_collect.package_extras is not None:
         task_group_attrs["pip_extras"] = task_collect.package_extras
+
+    # Set pinned_package_versions
     if task_collect.pinned_package_versions is not None:
         task_group_attrs[
             "pinned_package_versions"
         ] = task_collect.pinned_package_versions
+
+    # Set pkg_name, version, origin and wheel_path
     if task_collect.package.endswith(".whl"):
         try:
             task_group_attrs["wheel_path"] = task_collect.package
@@ -119,19 +126,11 @@ async def collect_tasks_pip(
         pkg_name = task_collect.package
         task_group_attrs["pkg_name"] = _normalize_package_name(pkg_name)
         task_group_attrs["origin"] = "pypi"
-        if task_collect.package_version is None:
-            latest_version = await get_package_version_from_pypi(
-                task_collect.package
-            )
-            task_group_attrs["version"] = latest_version
-            task_collect.package_version = latest_version
-        else:
-            task_group_attrs["version"] = task_collect.package_version
-
-    # Validate user settings (backend-specific)
-    user_settings = await validate_user_settings(
-        user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-    )
+        latest_version = await get_package_version_from_pypi(
+            task_collect.package,
+            task_collect.package_version,
+        )
+        task_group_attrs["version"] = latest_version
 
     # Validate query parameters related to user-group ownership
     user_group_id = await _get_valid_user_group_id(
@@ -140,9 +139,16 @@ async def collect_tasks_pip(
         user_id=user.id,
         db=db,
     )
+
+    # Set user_group_id
     task_group_attrs["user_group_id"] = user_group_id
 
-    # Construct task_group.path
+    # Validate user settings (backend-specific)
+    user_settings = await validate_user_settings(
+        user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+    )
+
+    # Set path and venv_path
     if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
         base_tasks_path = user_settings.ssh_tasks_dir
     else:
@@ -165,6 +171,8 @@ async def collect_tasks_pip(
             detail=f"Invalid task-group object. Original error: {e}",
         )
 
+    # Database checks
+
     # Verify non-duplication constraints
     await _verify_non_duplication_user_constraint(
         user_id=user.id,
@@ -191,15 +199,18 @@ async def collect_tasks_pip(
             ),
         )
 
-    # Verify that folder does not exist (for local collection)
+    # On-disk checks
+
     if settings.FRACTAL_RUNNER_BACKEND != "slurm_ssh":
+
+        # Verify that folder does not exist (for local collection)
         if Path(task_group_path).exists():
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                 detail=f"{task_group_path} already exists.",
             )
 
-    if settings.FRACTAL_RUNNER_BACKEND != "slurm_ssh":
+        # Verify that wheel file exists
         wheel_path = task_group_attrs.get("wheel_path", None)
         if wheel_path is not None:
             if not Path(wheel_path).exists():
@@ -216,13 +227,15 @@ async def collect_tasks_pip(
     db.expunge(task_group)
 
     # All checks are OK, proceed with task collection
-    collection_status = dict(
+    collection_state_data = dict(
         status=CollectionStatusV2.PENDING,
-        venv_path=task_group_attrs["venv_path"],
-        package=task_collect.package,
+        package=task_group.pkg_name,
+        version=task_group.version,
+        path=task_group.path,
+        venv_path=task_group.venv_path,
     )
     state = CollectionStateV2(
-        data=collection_status, taskgroupv2_id=task_group.id
+        data=collection_state_data, taskgroupv2_id=task_group.id
     )
     db.add(state)
     await db.commit()
@@ -270,7 +283,7 @@ async def collect_tasks_pip(
     reset_logger_handlers(logger)
     info = (
         "Collecting tasks in the background. "
-        f"GET /task/collect/{state.id} to query collection status"
+        f"GET /task/collect/{state.id}/ to query collection status"
     )
     state.data["info"] = info
     response.status_code = status.HTTP_201_CREATED
@@ -306,20 +319,17 @@ async def check_collection_status(
     else:
         # Non-SSH mode
         # In some cases (i.e. a successful or ongoing task collection),
-        # state.data.log is not set; if so, we collect the current logs.
+        # state.data["log"] is not set; if so, we collect the current logs.
         if verbose and not state.data.get("log"):
-            if "venv_path" not in state.data.keys():
+            if "path" not in state.data.keys():
                 await db.close()
                 raise HTTPException(
                     status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail=(
-                        f"No 'venv_path' in CollectionStateV2[{state_id}].data"
+                        f"No 'path' in CollectionStateV2[{state_id}].data"
                     ),
                 )
-            state.data["log"] = get_collection_log(
-                Path(state.data["venv_path"])
-            )
-            state.data["venv_path"] = str(state.data["venv_path"])
+            state.data["log"] = get_collection_log_v2(Path(state.data["path"]))
 
     reset_logger_handlers(logger)
     await db.close()

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/api/v2/task_group.py

@@ -143,12 +143,16 @@ async def patch_task_group(
         user_id=user.id,
         db=db,
     )
-    await _verify_non_duplication_group_constraint(
-        db=db,
-        pkg_name=task_group.pkg_name,
-        version=task_group.version,
-        user_group_id=task_group_update.user_group_id,
-    )
+    if (
+        "user_group_id" in task_group_update.dict(exclude_unset=True)
+        and task_group_update.user_group_id != task_group.user_group_id
+    ):
+        await _verify_non_duplication_group_constraint(
+            db=db,
+            pkg_name=task_group.pkg_name,
+            version=task_group.version,
+            user_group_id=task_group_update.user_group_id,
+        )
     for key, value in task_group_update.dict(exclude_unset=True).items():
         if (key == "user_group_id") and (value is not None):
             await _verify_user_belongs_to_group(

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/routes/api/v2/workflowtask.py

@@ -77,7 +77,6 @@ async def create_workflowtask(
     workflow_task = await _workflow_insert_task(
         workflow_id=workflow.id,
         task_id=task_id,
-        order=new_task.order,
         meta_non_parallel=new_task.meta_non_parallel,
         meta_parallel=new_task.meta_parallel,
         args_non_parallel=new_task.args_non_parallel,

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/schemas/v2/dumps.py

@@ -31,7 +31,6 @@ class TaskDumpV2(BaseModel):
     command_non_parallel: Optional[str]
     command_parallel: Optional[str]
     source: Optional[str] = None
-    owner: Optional[str]
     version: Optional[str]
 
     input_types: dict[str, bool]

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/schemas/v2/task.py

@@ -21,7 +21,6 @@ class TaskCreateV2(BaseModel, extra=Extra.forbid):
 
     command_non_parallel: Optional[str] = None
     command_parallel: Optional[str] = None
-    source: Optional[str] = None
 
     meta_non_parallel: Optional[dict[str, Any]] = None
     meta_parallel: Optional[dict[str, Any]] = None
@@ -64,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)(
@@ -137,7 +135,6 @@ class TaskReadV2(BaseModel):
 class TaskUpdateV2(BaseModel, extra=Extra.forbid):
 
     name: Optional[str] = None
-    version: Optional[str] = None
     command_parallel: Optional[str] = None
     command_non_parallel: Optional[str] = None
     input_types: Optional[dict[str, bool]] = None
@@ -156,9 +153,7 @@ class TaskUpdateV2(BaseModel, extra=Extra.forbid):
         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")
     )

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/app/schemas/v2/workflowtask.py

@@ -8,7 +8,6 @@ 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 TaskReadV2
@@ -42,7 +41,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 +50,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):

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/tasks/utils.py

@@ -9,9 +9,11 @@ COLLECTION_LOG_FILENAME = "collection.log"
 COLLECTION_FREEZE_FILENAME = "collection_freeze.txt"
 
 
-def get_absolute_venv_path(venv_path: Path) -> Path:
+def get_absolute_venv_path_v1(venv_path: Path) -> Path:
     """
     If a path is not absolute, make it a relative path of FRACTAL_TASKS_DIR.
+
+    As of v2.7.0, we rename this to v1 since it is only to be used in v1.
     """
     if venv_path.is_absolute():
         package_path = venv_path
@@ -33,20 +35,32 @@ def get_freeze_path(base: Path) -> Path:
     return base / COLLECTION_FREEZE_FILENAME
 
 
-def get_collection_log(venv_path: Path) -> str:
-    package_path = get_absolute_venv_path(venv_path)
+def get_collection_log_v1(path: Path) -> str:
+    package_path = get_absolute_venv_path_v1(path)
     log_path = get_log_path(package_path)
     log = log_path.open().read()
     return log
 
 
-def get_collection_freeze(venv_path: Path) -> str:
-    package_path = get_absolute_venv_path(venv_path)
+def get_collection_log_v2(path: Path) -> str:
+    log_path = get_log_path(path)
+    log = log_path.open().read()
+    return log
+
+
+def get_collection_freeze_v1(venv_path: Path) -> str:
+    package_path = get_absolute_venv_path_v1(venv_path)
     freeze_path = get_freeze_path(package_path)
     freeze = freeze_path.open().read()
     return freeze
 
 
+def get_collection_freeze_v2(path: Path) -> str:
+    freeze_path = get_freeze_path(path)
+    freeze = freeze_path.open().read()
+    return freeze
+
+
 def _normalize_package_name(name: str) -> str:
     """
     Implement PyPa specifications for package-name normalization

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/tasks/v1/background_operations.py

@@ -8,7 +8,7 @@ from shutil import rmtree as shell_rmtree
 
 from ...string_tools import slugify_task_name_for_source_v1
 from ..utils import _normalize_package_name
-from ..utils import get_collection_log
+from ..utils import get_collection_log_v1
 from ..utils import get_collection_path
 from ..utils import get_log_path
 from ._TaskCollectPip import _TaskCollectPip
@@ -321,7 +321,7 @@ async def background_collect_pip(
 
             # Update DB
             data.status = "OK"
-            data.log = get_collection_log(venv_path)
+            data.log = get_collection_log_v1(venv_path)
             state.data = data.sanitised_dict()
             db.add(state)
             db.merge(state)
@@ -342,7 +342,7 @@ async def background_collect_pip(
             # Update db
             data.status = "fail"
             data.info = f"Original error: {e}"
-            data.log = get_collection_log(venv_path)
+            data.log = get_collection_log_v1(venv_path)
             state.data = data.sanitised_dict()
             db.merge(state)
             db.commit()

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/tasks/v1/get_collection_data.py

@@ -2,12 +2,12 @@ import json
 from pathlib import Path
 
 from fractal_server.app.schemas.v1 import TaskCollectStatusV1
-from fractal_server.tasks.utils import get_absolute_venv_path
+from fractal_server.tasks.utils import get_absolute_venv_path_v1
 from fractal_server.tasks.utils import get_collection_path
 
 
 def get_collection_data(venv_path: Path) -> TaskCollectStatusV1:
-    package_path = get_absolute_venv_path(venv_path)
+    package_path = get_absolute_venv_path_v1(venv_path)
     collection_path = get_collection_path(package_path)
     with collection_path.open() as f:
         data = json.load(f)

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/fractal_server/tasks/v2/background_operations.py

@@ -14,8 +14,8 @@ from sqlalchemy.orm import Session as DBSyncSession
 from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 
-from ..utils import get_collection_freeze
-from ..utils import get_collection_log
+from ..utils import get_collection_freeze_v2
+from ..utils import get_collection_log_v2
 from ..utils import get_collection_path
 from ..utils import get_log_path
 from .database_operations import create_db_tasks_and_update_task_group
@@ -419,10 +419,10 @@ async def background_collect_pip(
                 for task in task_group.task_list
             ]
             collection_state.data["task_list"] = task_read_list
-            collection_state.data["log"] = get_collection_log(
+            collection_state.data["log"] = get_collection_log_v2(
                 Path(task_group.path)
             )
-            collection_state.data["freeze"] = get_collection_freeze(
+            collection_state.data["freeze"] = get_collection_freeze_v2(
                 Path(task_group.path)
             )
             with collection_path.open("w") as f:

fractal_server-2.7.0a5/fractal_server/tasks/v2/endpoint_operations.py

@@ -0,0 +1,124 @@
+from typing import Optional
+
+from fastapi import HTTPException
+from fastapi import status
+from httpx import AsyncClient
+from httpx import TimeoutException
+
+from fractal_server.logger import set_logger
+
+
+logger = set_logger(__name__)
+
+
+async def get_package_version_from_pypi(
+    name: str,
+    version: Optional[str] = None,
+) -> str:
+    """
+    Make a GET call to PyPI JSON API and get latest *compatible* version.
+
+    There are three cases:
+
+    1. `version` is set and it is found on PyPI as-is.
+    2. `version` is set but it is not found on PyPI as-is.
+    3. `version` is unset, and we query `PyPI` for latest.
+
+    Ref https://warehouse.pypa.io/api-reference/json.html.
+
+    Arguments:
+        name: Package name.
+        version:
+            Could be a correct version (`1.3.0`), an incomplete one
+            (`1.3`) or `None`.
+    """
+
+    url = f"https://pypi.org/pypi/{name}/json"
+    hint = f"Hint: specify the required version for '{name}'."
+
+    # Make request to PyPI
+    try:
+        async with AsyncClient(timeout=5.0) as client:
+            res = await client.get(url)
+    except TimeoutException as e:
+        error_msg = (
+            f"A TimeoutException occurred while getting {url}.\n"
+            f"Original error: {str(e)}."
+        )
+        logger.error(error_msg)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=error_msg,
+        )
+    except BaseException as e:
+        error_msg = (
+            f"An unknown error occurred while getting {url}. "
+            f"Original error: {str(e)}."
+        )
+        logger.error(error_msg)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=error_msg,
+        )
+
+    # Parse response
+    if res.status_code != 200:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Could not get {url} (status_code {res.status_code})."
+                f"\n{hint}"
+            ),
+        )
+    try:
+        response_data = res.json()
+        latest_version = response_data["info"]["version"]
+        available_releases = response_data["releases"].keys()
+    except KeyError as e:
+        logger.error(
+            f"A KeyError occurred while getting {url}. "
+            f"Original error: {str(e)}."
+        )
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"A KeyError error occurred while getting {url}.\n{hint}",
+        )
+
+    logger.info(
+        f"Obtained data from {url}: "
+        f"{len(available_releases)} releases, "
+        f"latest={latest_version}."
+    )
+
+    if version is not None:
+        if version in available_releases:
+            logger.info(f"Requested {version=} available on PyPI.")
+            # Case 1: `version` is set and it is found on PyPI as-is
+            return version
+        else:
+            # Case 2: `version` is set but it is not found on PyPI as-is
+            # Filter using `version` as prefix, and sort
+            matching_versions = [
+                v for v in available_releases if v.startswith(version)
+            ]
+            logger.info(
+                f"Requested {version=} not available on PyPI, "
+                f"found {len(matching_versions)} versions matching "
+                f"`{version}*`."
+            )
+            if len(matching_versions) == 0:
+                logger.info(f"No version starting with {version} found.")
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=(
+                        f"No version starting with {version} found.\n"
+                        f"{hint}"
+                    ),
+                )
+            else:
+                latest_matching_version = sorted(matching_versions)[-1]
+                return latest_matching_version
+    else:
+        # Case 3: `version` is unset and we use latest
+        logger.info(f"No version requested, returning {latest_version=}.")
+        return latest_version

{fractal_server-2.7.0a4 → fractal_server-2.7.0a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fractal-server"
-version = "2.7.0a4"
+version = "2.7.0a5"
 description = "Server component of the Fractal analytics platform"
 authors = [
     "Tommaso Comparin <tommaso.comparin@exact-lab.it>",
@@ -92,7 +92,7 @@ filterwarnings = [
 ]
 
 [tool.bumpver]
-current_version = "2.7.0a4"
+current_version = "2.7.0a5"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

fractal_server-2.7.0a4/fractal_server/__init__.py

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