fractal-server 2.14.16__py3-none-any.whl → 2.15.0a1__py3-none-any.whl

fractal_server/__init__.py

@@ -1 +1 @@
-__VERSION__ = "2.14.16"
+__VERSION__ = "2.15.0a1"

fractal_server/app/models/v2/task_group.py

@@ -29,8 +29,9 @@ class TaskGroupV2(SQLModel, table=True):
     pkg_name: str
     version: str | None = None
     python_version: str | None = None
+    pixi_version: str | None = None
     path: str | None = None
-    wheel_path: str | None = None
+    archive_path: str | None = None
     pip_extras: str | None = None
     pinned_package_versions: dict[str, str] = Field(
         sa_column=Column(
@@ -40,7 +41,7 @@ class TaskGroupV2(SQLModel, table=True):
             nullable=True,
         ),
     )
-    pip_freeze: str | None = None
+    env_info: str | None = None
     venv_path: str | None = None
     venv_size_in_kB: int | None = None
     venv_file_number: int | None = None
@@ -66,15 +67,20 @@ class TaskGroupV2(SQLModel, table=True):
         """
         Prepare string to be used in `python -m pip install`.
         """
+        if self.origin == "pixi":
+            raise ValueError(
+                f"Cannot call 'pip_install_string' if {self.origin=}."
+            )
+
         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}"
+        if self.archive_path is not None:
+            return f"{self.archive_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=}."
+                    f"{self.pkg_name=}, {self.archive_path=}, {self.version=}."
                 )
             return f"{self.pkg_name}{extras}=={self.version}"
 
@@ -83,6 +89,12 @@ class TaskGroupV2(SQLModel, table=True):
         """
         Prepare string to be used in `python -m pip install`.
         """
+        if self.origin == "pixi":
+            raise ValueError(
+                "Cannot call 'pinned_package_versions_string' if "
+                f"{self.origin=}."
+            )
+
         if self.pinned_package_versions is None:
             return ""
         output = " ".join(

fractal_server/app/routes/admin/v2/task_group_lifecycle.py

@@ -207,12 +207,12 @@ async def reactivate_task_group(
         response.status_code = status.HTTP_202_ACCEPTED
         return task_group_activity
 
-    if task_group.pip_freeze is None:
+    if task_group.env_info is None:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
                 "Cannot reactivate a task group with "
-                f"{task_group.pip_freeze=}."
+                f"{task_group.env_info=}."
             ),
         )
 

fractal_server/app/routes/api/v2/__init__.py

@@ -14,6 +14,7 @@ from .submit import router as submit_job_router_v2
 from .task import router as task_router_v2
 from .task_collection import router as task_collection_router_v2
 from .task_collection_custom import router as task_collection_router_v2_custom
+from .task_collection_pixi import router as task_collection_pixi_router_v2
 from .task_group import router as task_group_router_v2
 from .task_group_lifecycle import router as task_group_lifecycle_router_v2
 from .task_version_update import router as task_version_update_router_v2
@@ -49,6 +50,11 @@ router_api_v2.include_router(
     prefix="/task",
     tags=["V2 Task Lifecycle"],
 )
+router_api_v2.include_router(
+    task_collection_pixi_router_v2,
+    prefix="/task",
+    tags=["V2 Task Lifecycle"],
+)
 router_api_v2.include_router(
     task_group_lifecycle_router_v2,
     prefix="/task-group",

fractal_server/app/routes/api/v2/task_collection.py

@@ -23,11 +23,11 @@ from .....syringe import Inject
 from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import TaskGroupV2
+from ....schemas.v2 import FractalUploadedFile
 from ....schemas.v2 import TaskCollectPipV2
 from ....schemas.v2 import TaskGroupActivityStatusV2
 from ....schemas.v2 import TaskGroupActivityV2Read
 from ....schemas.v2 import TaskGroupCreateV2Strict
-from ....schemas.v2 import WheelFile
 from ...aux.validate_user_settings import validate_user_settings
 from ._aux_functions_task_lifecycle import get_package_version_from_pypi
 from ._aux_functions_tasks import _get_valid_user_group_id
@@ -208,13 +208,13 @@ async def collect_tasks_pip(
     # Initialize wheel_file_content as None
     wheel_file = None
 
-    # Set pkg_name, version, origin and wheel_path
+    # Set pkg_name, version, origin and archive_path
     if request_data.origin == TaskGroupV2OriginEnum.WHEELFILE:
         try:
             wheel_filename = request_data.file.filename
             wheel_info = _parse_wheel_filename(wheel_filename)
             wheel_file_content = await request_data.file.read()
-            wheel_file = WheelFile(
+            wheel_file = FractalUploadedFile(
                 filename=wheel_filename,
                 contents=wheel_file_content,
             )

fractal_server/app/routes/api/v2/task_collection_custom.py

@@ -26,7 +26,7 @@ from fractal_server.logger import set_logger
 from fractal_server.string_tools import validate_cmd
 from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.utils_background import (
-    _prepare_tasks_metadata,
+    prepare_tasks_metadata,
 )
 from fractal_server.tasks.v2.utils_database import (
     create_db_tasks_and_update_task_group_async,
@@ -138,7 +138,7 @@ async def collect_task_custom(
     else:
         package_root = Path(task_collect.package_root)
 
-    task_list: list[TaskCreateV2] = _prepare_tasks_metadata(
+    task_list: list[TaskCreateV2] = prepare_tasks_metadata(
         package_manifest=task_collect.manifest,
         python_bin=Path(task_collect.python_interpreter),
         package_root=package_root,

fractal_server/app/routes/api/v2/task_collection_pixi.py

@@ -0,0 +1,236 @@
+import os
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi import BackgroundTasks
+from fastapi import Depends
+from fastapi import Form
+from fastapi import HTTPException
+from fastapi import Request
+from fastapi import Response
+from fastapi import status
+from fastapi import UploadFile
+from pydantic import ValidationError
+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 TaskGroupActivityV2
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _get_valid_user_group_id,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_group_constraint,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _verify_non_duplication_user_constraint,
+)
+from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.aux.validate_user_settings import (
+    validate_user_settings,
+)
+from fractal_server.app.schemas.v2 import FractalUploadedFile
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
+from fractal_server.app.schemas.v2 import TaskGroupCreateV2StrictPixi
+from fractal_server.app.schemas.v2.task_group import TaskGroupV2OriginEnum
+from fractal_server.config import get_settings
+from fractal_server.logger import set_logger
+from fractal_server.ssh._fabric import SSHConfig
+from fractal_server.syringe import Inject
+from fractal_server.tasks.v2.local import collect_local_pixi
+from fractal_server.tasks.v2.ssh import collect_ssh_pixi
+from fractal_server.tasks.v2.utils_package_names import normalize_package_name
+from fractal_server.types import NonEmptyStr
+
+
+router = APIRouter()
+
+logger = set_logger(__name__)
+
+
+def validate_pkgname_and_version(filename: str) -> tuple[str, str]:
+    if not filename.endswith(".tar.gz"):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"{filename=} does not end with '.tar.gz'.",
+        )
+    filename_splitted = filename.split("-")
+    if len(filename_splitted) != 2:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Invalid filename: '{filename}' must contain a single `-` "
+                "character, separating the package name from the version "
+                "(expected format: 'pkg_name-version')."
+            ),
+        )
+
+    pkg_name = filename_splitted[0]
+    version = filename.removeprefix(f"{pkg_name}-").removesuffix(".tar.gz")
+
+    return normalize_package_name(pkg_name), version
+
+
+@router.post(
+    "/collect/pixi/",
+    status_code=202,
+    response_model=TaskGroupActivityV2Read,
+)
+async def collect_task_pixi(
+    request: Request,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    file: UploadFile,
+    pixi_version: NonEmptyStr | None = Form(None),
+    private: bool = False,
+    user_group_id: int | None = None,
+    user: UserOAuth = Depends(current_active_verified_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupActivityV2Read:
+
+    settings = Inject(get_settings)
+    # Check if Pixi is available
+    if settings.pixi is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Pixi task collection is not available.",
+        )
+    # Check if provided Pixi version is available. Use default if not provided
+    if pixi_version is None:
+        pixi_version = settings.pixi.default_version
+    else:
+        if pixi_version not in settings.pixi.versions:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=(
+                    f"Pixi version {pixi_version} is not available. Available "
+                    f"versions: {list(settings.pixi.versions.keys())}"
+                ),
+            )
+
+    pkg_name, version = validate_pkgname_and_version(file.filename)
+    tar_gz_content = await file.read()
+    tar_gz_file = FractalUploadedFile(
+        filename=file.filename,
+        contents=tar_gz_content,
+    )
+
+    user_group_id = await _get_valid_user_group_id(
+        user_group_id=user_group_id,
+        private=private,
+        user_id=user.id,
+        db=db,
+    )
+
+    user_settings = await validate_user_settings(
+        user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+    )
+
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        base_tasks_path = user_settings.ssh_tasks_dir
+    else:
+        base_tasks_path = settings.FRACTAL_TASKS_DIR.as_posix()
+    task_group_path = (
+        Path(base_tasks_path) / str(user.id) / pkg_name / version
+    ).as_posix()
+
+    task_group_attrs = dict(
+        user_id=user.id,
+        user_group_id=user_group_id,
+        origin=TaskGroupV2OriginEnum.PIXI,
+        pixi_version=pixi_version,
+        pkg_name=pkg_name,
+        version=version,
+        path=task_group_path,
+    )
+    try:
+        TaskGroupCreateV2StrictPixi(**task_group_attrs)
+    except ValidationError as e:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Invalid task-group object. Original error: {e}",
+        )
+
+    await _verify_non_duplication_user_constraint(
+        user_id=user.id,
+        pkg_name=task_group_attrs["pkg_name"],
+        version=task_group_attrs["version"],
+        db=db,
+    )
+    await _verify_non_duplication_group_constraint(
+        user_group_id=task_group_attrs["user_group_id"],
+        pkg_name=task_group_attrs["pkg_name"],
+        version=task_group_attrs["version"],
+        db=db,
+    )
+
+    # FIXME: to be removed with issue #2634
+    stm = select(TaskGroupV2).where(TaskGroupV2.path == task_group_path)
+    res = await db.execute(stm)
+    for conflicting_task_group in res.scalars().all():
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Another task-group already has path={task_group_path}.\n"
+                f"{conflicting_task_group=}"
+            ),
+        )
+
+    if settings.FRACTAL_RUNNER_BACKEND != "slurm_ssh":
+        if Path(task_group_path).exists():
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"{task_group_path} already exists.",
+            )
+
+    task_group = TaskGroupV2(**task_group_attrs)
+    db.add(task_group)
+    await db.commit()
+    await db.refresh(task_group)
+    db.expunge(task_group)
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.COLLECT,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+    )
+    db.add(task_group_activity)
+    await db.commit()
+    await db.refresh(task_group_activity)
+
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        ssh_config = SSHConfig(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+
+        background_tasks.add_task(
+            collect_ssh_pixi,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            ssh_config=ssh_config,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+            tar_gz_file=tar_gz_file,
+        )
+    else:
+        background_tasks.add_task(
+            collect_local_pixi,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            tar_gz_file=tar_gz_file,
+        )
+    logger.info(
+        "Task-collection endpoint: start background collection "
+        "and return task_group_activity. "
+        f"Current pid is {os.getpid()}. "
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity

fractal_server/app/routes/api/v2/task_group_lifecycle.py

@@ -25,9 +25,13 @@ from fractal_server.logger import set_logger
 from fractal_server.ssh._fabric import SSHConfig
 from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.local import deactivate_local
+from fractal_server.tasks.v2.local import deactivate_local_pixi
 from fractal_server.tasks.v2.local import reactivate_local
+from fractal_server.tasks.v2.local import reactivate_local_pixi
 from fractal_server.tasks.v2.ssh import deactivate_ssh
+from fractal_server.tasks.v2.ssh import deactivate_ssh_pixi
 from fractal_server.tasks.v2.ssh import reactivate_ssh
+from fractal_server.tasks.v2.ssh import reactivate_ssh_pixi
 from fractal_server.utils import get_timestamp
 
 router = APIRouter()
@@ -125,9 +129,12 @@ async def deactivate_task_group(
             host=user_settings.ssh_host,
             key_path=user_settings.ssh_private_key_path,
         )
-
+        if task_group.origin == TaskGroupV2OriginEnum.PIXI:
+            deactivate_function = deactivate_ssh_pixi
+        else:
+            deactivate_function = deactivate_ssh
         background_tasks.add_task(
-            deactivate_ssh,
+            deactivate_function,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
             ssh_config=ssh_config,
@@ -135,8 +142,12 @@ async def deactivate_task_group(
         )
 
     else:
+        if task_group.origin == TaskGroupV2OriginEnum.PIXI:
+            deactivate_function = deactivate_local_pixi
+        else:
+            deactivate_function = deactivate_local
         background_tasks.add_task(
-            deactivate_local,
+            deactivate_function,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
         )
@@ -210,12 +221,12 @@ async def reactivate_task_group(
         response.status_code = status.HTTP_202_ACCEPTED
         return task_group_activity
 
-    if task_group.pip_freeze is None:
+    if task_group.env_info is None:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
                 "Cannot reactivate a task group with "
-                f"{task_group.pip_freeze=}."
+                f"{task_group.env_info=}."
             ),
         )
 
@@ -247,8 +258,12 @@ async def reactivate_task_group(
             key_path=user_settings.ssh_private_key_path,
         )
 
+        if task_group.origin == TaskGroupV2OriginEnum.PIXI:
+            reactivate_function = reactivate_ssh_pixi
+        else:
+            reactivate_function = reactivate_ssh
         background_tasks.add_task(
-            reactivate_ssh,
+            reactivate_function,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
             ssh_config=ssh_config,
@@ -256,8 +271,12 @@ async def reactivate_task_group(
         )
 
     else:
+        if task_group.origin == TaskGroupV2OriginEnum.PIXI:
+            reactivate_function = reactivate_local_pixi
+        else:
+            reactivate_function = reactivate_local
         background_tasks.add_task(
-            reactivate_local,
+            reactivate_function,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
         )

fractal_server/app/schemas/v2/__init__.py

@@ -33,14 +33,15 @@ from .task import TaskImportV2Legacy  # noqa F401
 from .task import TaskReadV2  # noqa F401
 from .task import TaskType  # noqa F401
 from .task import TaskUpdateV2  # noqa F401
+from .task_collection import FractalUploadedFile  # noqa F401
 from .task_collection import TaskCollectCustomV2  # noqa F401
 from .task_collection import TaskCollectPipV2  # noqa F401
-from .task_collection import WheelFile  # noqa F401
 from .task_group import TaskGroupActivityActionV2  # noqa F401
 from .task_group import TaskGroupActivityStatusV2  # noqa F401
 from .task_group import TaskGroupActivityV2Read  # noqa F401
 from .task_group import TaskGroupCreateV2  # noqa F401
 from .task_group import TaskGroupCreateV2Strict  # noqa F401
+from .task_group import TaskGroupCreateV2StrictPixi  # noqa F401
 from .task_group import TaskGroupReadV2  # noqa F401
 from .task_group import TaskGroupUpdateV2  # noqa F401
 from .task_group import TaskGroupV2OriginEnum  # noqa F401

fractal_server/app/schemas/v2/dumps.py

@@ -86,4 +86,4 @@ class TaskGroupDumpV2(BaseModel):
 
     path: str | None = None
     venv_path: str | None = None
-    wheel_path: str | None = None
+    archive_path: str | None = None

fractal_server/app/schemas/v2/task_collection.py

@@ -12,7 +12,7 @@ from fractal_server.types import DictStrStr
 from fractal_server.types import NonEmptyStr
 
 
-class WheelFile(BaseModel):
+class FractalUploadedFile(BaseModel):
     """
     Model for data sent from the endpoint to the background task.
     """

fractal_server/app/schemas/v2/task_group.py

@@ -16,6 +16,7 @@ from fractal_server.types import NonEmptyStr
 class TaskGroupV2OriginEnum(StrEnum):
     PYPI = "pypi"
     WHEELFILE = "wheel-file"
+    PIXI = "pixi"
     OTHER = "other"
 
 
@@ -41,11 +42,12 @@ class TaskGroupCreateV2(BaseModel):
     pkg_name: str
     version: str | None = None
     python_version: NonEmptyStr = None
+    pixi_version: NonEmptyStr = None
     path: AbsolutePathStr = None
     venv_path: AbsolutePathStr = None
-    wheel_path: AbsolutePathStr = None
+    archive_path: AbsolutePathStr = None
     pip_extras: NonEmptyStr = None
-    pip_freeze: str | None = None
+    env_info: str | None = None
     pinned_package_versions: DictStrStr = Field(default_factory=dict)
 
 
@@ -55,11 +57,20 @@ class TaskGroupCreateV2Strict(TaskGroupCreateV2):
     """
 
     path: AbsolutePathStr
-    venv_path: AbsolutePathStr
     version: NonEmptyStr
+    venv_path: AbsolutePathStr
     python_version: NonEmptyStr
 
 
+class TaskGroupCreateV2StrictPixi(TaskGroupCreateV2):
+    """
+    A strict version of TaskGroupCreateV2, to be used for pixi task collection.
+    """
+
+    path: AbsolutePathStr
+    pixi_version: NonEmptyStr
+
+
 class TaskGroupReadV2(BaseModel):
     id: int
     task_list: list[TaskReadV2]
@@ -71,10 +82,10 @@ class TaskGroupReadV2(BaseModel):
     pkg_name: str
     version: str | None = None
     python_version: str | None = None
+    pixi_version: str | None = None
     path: str | None = None
     venv_path: str | None = None
-    wheel_path: str | None = None
-    pip_freeze: str | None = None
+    archive_path: str | None = None
     pip_extras: str | None = None
     pinned_package_versions: dict[str, str] = Field(default_factory=dict)
 

fractal_server/config.py

@@ -11,6 +11,7 @@
 # <exact-lab.it> under contract with Liberali Lab from the Friedrich Miescher
 # Institute for Biomedical Research and Pelkmans Lab from the University of
 # Zurich.
+import json
 import logging
 import shutil
 import sys
@@ -34,6 +35,7 @@ from sqlalchemy.engine import URL
 
 import fractal_server
 from fractal_server.types import AbsolutePathStr
+from fractal_server.types import DictStrStr
 
 
 class MailSettings(BaseModel):
@@ -62,6 +64,35 @@ class MailSettings(BaseModel):
     use_login: bool
 
 
+class PixiSettings(BaseModel):
+    default_version: str
+    versions: DictStrStr
+
+    @model_validator(mode="after")
+    def check_pixi_settings(self):
+
+        if self.default_version not in self.versions:
+            raise ValueError(
+                f"Default version '{self.default_version}' not in "
+                f"available version {list(self.versions.keys())}."
+            )
+
+        pixi_base_dir = Path(self.versions[self.default_version]).parent
+
+        for key, value in self.versions.items():
+
+            pixi_path = Path(value)
+
+            if pixi_path.parent != pixi_base_dir:
+                raise ValueError(
+                    f"{pixi_path=} is not located within the {pixi_base_dir=}."
+                )
+            if pixi_path.name != key:
+                raise ValueError(f"{pixi_path.name=} is not equal to {key=}")
+
+        return self
+
+
 class FractalConfigurationError(RuntimeError):
     pass
 
@@ -513,6 +544,17 @@ class Settings(BaseSettings):
     FRACTAL_VIEWER_AUTHORIZATION_SCHEME is set to "users-folders".
     """
 
+    FRACTAL_PIXI_CONFIG_FILE: Path | None = None
+
+    pixi: PixiSettings | None = None
+
+    @model_validator(mode="after")
+    def populate_pixi_settings(self):
+        if self.FRACTAL_PIXI_CONFIG_FILE is not None:
+            with self.FRACTAL_PIXI_CONFIG_FILE.open("r") as f:
+                self.pixi = PixiSettings(**json.load(f))
+        return self
+
     ###########################################################################
     # SMTP SERVICE
     ###########################################################################

fractal_server/migrations/versions/b1e7f7a1ff71_task_group_for_pixi.py

@@ -0,0 +1,53 @@
+"""Task group for pixi
+
+Revision ID: b1e7f7a1ff71
+Revises: 791ce783d3d8
+Create Date: 2025-05-29 16:31:17.565973
+
+"""
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = "b1e7f7a1ff71"
+down_revision = "791ce783d3d8"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("taskgroupv2", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "pixi_version",
+                sqlmodel.sql.sqltypes.AutoString(),
+                nullable=True,
+            )
+        )
+        batch_op.alter_column(
+            "wheel_path",
+            nullable=True,
+            new_column_name="archive_path",
+        )
+        batch_op.alter_column(
+            "pip_freeze",
+            nullable=True,
+            new_column_name="env_info",
+        )
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("taskgroupv2", schema=None) as batch_op:
+        batch_op.alter_column(
+            "archive_path",
+            nullable=True,
+            new_column_name="wheel_path",
+        )
+        batch_op.alter_column(
+            "env_info",
+            nullable=True,
+            new_column_name="pip_freeze",
+        )
+        batch_op.drop_column("pixi_version")