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

fractal_server/tasks/v2/ssh/reactivate.py

@@ -1,15 +1,14 @@
-import logging
 import time
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
 from ..utils_background import add_commit_refresh
 from ..utils_background import fail_and_cleanup
+from ..utils_background import get_activity_and_task_group
 from ..utils_templates import get_collection_replacements
 from ._utils import _customize_and_run_template
+from ._utils import check_ssh_or_fail_and_cleanup
 from fractal_server.app.db import get_sync_db
-from fractal_server.app.models.v2 import TaskGroupActivityV2
-from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2.task_group import TaskGroupActivityStatusV2
 from fractal_server.logger import reset_logger_handlers
@@ -56,46 +55,34 @@ def reactivate_ssh(
             log_file_path=log_file_path,
         )
 
-        with SingleUseFractalSSH(
-            ssh_config=ssh_config,
-            logger_name=LOGGER_NAME,
-        ) as fractal_ssh:
-
-            with next(get_sync_db()) as db:
-
-                # Get main objects from db
-                activity = db.get(TaskGroupActivityV2, task_group_activity_id)
-                task_group = db.get(TaskGroupV2, task_group_id)
-                if activity is None or task_group is None:
-                    # Use `logging` directly
-                    logging.error(
-                        "Cannot find database rows with "
-                        f"{task_group_id=} and {task_group_activity_id=}:\n"
-                        f"{task_group=}\n{activity=}. Exit."
-                    )
-                    return
-
-                # Log some info
-                logger.info("START")
-                for key, value in task_group.model_dump().items():
-                    logger.debug(f"task_group.{key}: {value}")
-
-                # Check that SSH connection works
+        logger.info("START")
+        with next(get_sync_db()) as db:
+            db_objects_ok, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+                logger_name=LOGGER_NAME,
+            )
+            if not db_objects_ok:
+                return
+
+            with SingleUseFractalSSH(
+                ssh_config=ssh_config,
+                logger_name=LOGGER_NAME,
+            ) as fractal_ssh:
                 try:
-                    fractal_ssh.check_connection()
-                except Exception as e:
-                    logger.error("Cannot establish SSH connection.")
-                    fail_and_cleanup(
+                    # Check SSH connection
+                    ssh_ok = check_ssh_or_fail_and_cleanup(
+                        fractal_ssh=fractal_ssh,
                         task_group=task_group,
                         task_group_activity=activity,
                         logger_name=LOGGER_NAME,
                         log_file_path=log_file_path,
-                        exception=e,
                         db=db,
                     )
-                    return
+                    if not ssh_ok:
+                        return
 
-                try:
                     # Check that the (remote) task_group venv_path does not
                     # exist
                     if fractal_ssh.remote_exists(task_group.venv_path):
@@ -128,7 +115,7 @@ def reactivate_ssh(
                         Path(task_group.path) / "_tmp_pip_freeze.txt"
                     ).as_posix()
                     with open(pip_freeze_file_local, "w") as f:
-                        f.write(task_group.pip_freeze)
+                        f.write(task_group.env_info)
                     fractal_ssh.send_file(
                         local=pip_freeze_file_local,
                         remote=pip_freeze_file_remote,
@@ -199,8 +186,8 @@ def reactivate_ssh(
                         logger.info(f"Deleted folder {task_group.venv_path}")
                     except Exception as rm_e:
                         logger.error(
-                            "Removing folder failed.\n"
-                            f"Original error:\n{str(rm_e)}"
+                            "Removing folder failed. "
+                            f"Original error: {str(rm_e)}"
                         )
 
                     fail_and_cleanup(

fractal_server/tasks/v2/ssh/reactivate_pixi.py

@@ -0,0 +1,233 @@
+import time
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from ..utils_background import fail_and_cleanup
+from ..utils_background import get_activity_and_task_group
+from ..utils_pixi import SOURCE_DIR_NAME
+from ._utils import check_ssh_or_fail_and_cleanup
+from fractal_server.app.db import get_sync_db
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.config import get_settings
+from fractal_server.logger import reset_logger_handlers
+from fractal_server.logger import set_logger
+from fractal_server.ssh._fabric import SingleUseFractalSSH
+from fractal_server.ssh._fabric import SSHConfig
+from fractal_server.syringe import Inject
+from fractal_server.tasks.utils import get_log_path
+from fractal_server.tasks.v2.ssh._utils import _customize_and_run_template
+from fractal_server.tasks.v2.utils_background import add_commit_refresh
+from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.tasks.v2.utils_templates import SCRIPTS_SUBFOLDER
+from fractal_server.utils import get_timestamp
+
+
+def reactivate_ssh_pixi(
+    *,
+    task_group_activity_id: int,
+    task_group_id: int,
+    ssh_config: SSHConfig,
+    tasks_base_dir: str,
+) -> None:
+    """
+    Reactivate a task group venv.
+
+    This function is run as a background task, therefore exceptions must be
+    handled.
+
+    Arguments:
+        task_group_id:
+        task_group_activity_id:
+        ssh_config:
+        tasks_base_dir:
+            Only used as a `safe_root` in `remove_dir`, and typically set to
+            `user_settings.ssh_tasks_dir`.
+    """
+
+    LOGGER_NAME = f"{__name__}.ID{task_group_activity_id}"
+
+    with TemporaryDirectory() as tmpdir:
+        log_file_path = get_log_path(Path(tmpdir))
+        logger = set_logger(
+            logger_name=LOGGER_NAME,
+            log_file_path=log_file_path,
+        )
+
+        logger.info("START")
+        with next(get_sync_db()) as db:
+            db_objects_ok, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+                logger_name=LOGGER_NAME,
+            )
+            if not db_objects_ok:
+                return
+
+            with SingleUseFractalSSH(
+                ssh_config=ssh_config,
+                logger_name=LOGGER_NAME,
+            ) as fractal_ssh:
+                try:
+                    # Check SSH connection
+                    ssh_ok = check_ssh_or_fail_and_cleanup(
+                        fractal_ssh=fractal_ssh,
+                        task_group=task_group,
+                        task_group_activity=activity,
+                        logger_name=LOGGER_NAME,
+                        log_file_path=log_file_path,
+                        db=db,
+                    )
+                    if not ssh_ok:
+                        return
+
+                    # Check that the (remote) task_group source_dir does not
+                    # exist
+                    source_dir = Path(
+                        task_group.path, SOURCE_DIR_NAME
+                    ).as_posix()
+                    if fractal_ssh.remote_exists(source_dir):
+                        error_msg = f"{source_dir} already exists."
+                        logger.error(error_msg)
+                        fail_and_cleanup(
+                            task_group=task_group,
+                            task_group_activity=activity,
+                            logger_name=LOGGER_NAME,
+                            log_file_path=log_file_path,
+                            exception=FileExistsError(error_msg),
+                            db=db,
+                        )
+                        return
+
+                    settings = Inject(get_settings)
+                    replacements = {
+                        (
+                            "__PIXI_HOME__",
+                            settings.pixi.versions[task_group.pixi_version],
+                        ),
+                        ("__PACKAGE_DIR__", task_group.path),
+                        ("__TAR_GZ_PATH__", task_group.archive_path),
+                        (
+                            "__IMPORT_PACKAGE_NAME__",
+                            task_group.pkg_name.replace("-", "_"),
+                        ),
+                        ("__SOURCE_DIR_NAME__", SOURCE_DIR_NAME),
+                        ("__FROZEN_OPTION__", "--frozen"),
+                        (
+                            "__TOKIO_WORKER_THREADS__",
+                            str(settings.pixi.TOKIO_WORKER_THREADS),
+                        ),
+                        (
+                            "__PIXI_CONCURRENT_SOLVES__",
+                            str(settings.pixi.PIXI_CONCURRENT_SOLVES),
+                        ),
+                        (
+                            "__PIXI_CONCURRENT_DOWNLOADS__",
+                            str(settings.pixi.PIXI_CONCURRENT_DOWNLOADS),
+                        ),
+                    }
+
+                    logger.info("installing - START")
+
+                    # Set status to ONGOING and refresh logs
+                    activity.status = TaskGroupActivityStatusV2.ONGOING
+                    activity.log = get_current_log(log_file_path)
+                    activity = add_commit_refresh(obj=activity, db=db)
+
+                    script_dir_remote = Path(
+                        task_group.path, SCRIPTS_SUBFOLDER
+                    ).as_posix()
+                    common_args = dict(
+                        script_dir_local=(
+                            Path(tmpdir) / SCRIPTS_SUBFOLDER
+                        ).as_posix(),
+                        script_dir_remote=script_dir_remote,
+                        prefix=(
+                            f"{int(time.time())}_"
+                            f"{TaskGroupActivityActionV2.REACTIVATE}"
+                        ),
+                        logger_name=LOGGER_NAME,
+                        fractal_ssh=fractal_ssh,
+                    )
+
+                    # Run script 1 - extract tar.gz into `source_dir`
+                    stdout = _customize_and_run_template(
+                        template_filename="pixi_1_extract.sh",
+                        replacements=replacements,
+                        **common_args,
+                    )
+                    logger.debug(f"STDOUT: {stdout}")
+                    activity.log = get_current_log(log_file_path)
+                    activity = add_commit_refresh(obj=activity, db=db)
+
+                    # Write pixi.lock into `source_dir`
+                    pixi_lock_local = Path(tmpdir, "pixi.lock").as_posix()
+                    pixi_lock_remote = Path(
+                        task_group.path, SOURCE_DIR_NAME, "pixi.lock"
+                    ).as_posix()
+                    logger.info(
+                        f"Write `env_info` contents into {pixi_lock_local}"
+                    )
+                    with open(pixi_lock_local, "w") as f:
+                        f.write(task_group.env_info)
+                    fractal_ssh.send_file(
+                        local=pixi_lock_local,
+                        remote=pixi_lock_remote,
+                    )
+
+                    # Run script 2 - run pixi-install command
+                    stdout = _customize_and_run_template(
+                        template_filename="pixi_2_install.sh",
+                        replacements=replacements,
+                        **common_args,
+                    )
+                    logger.debug(f"STDOUT: {stdout}")
+                    activity.log = get_current_log(log_file_path)
+                    activity = add_commit_refresh(obj=activity, db=db)
+
+                    # Run script 3 - post-install
+                    stdout = _customize_and_run_template(
+                        template_filename="pixi_3_post_install.sh",
+                        replacements=replacements,
+                        **common_args,
+                    )
+                    logger.debug(f"STDOUT: {stdout}")
+                    activity.log = get_current_log(log_file_path)
+                    activity = add_commit_refresh(obj=activity, db=db)
+
+                    fractal_ssh.run_command(cmd=f"chmod 755 {source_dir} -R")
+
+                    # Finalize (write metadata to DB)
+                    activity.status = TaskGroupActivityStatusV2.OK
+                    activity.timestamp_ended = get_timestamp()
+                    activity = add_commit_refresh(obj=activity, db=db)
+                    task_group.active = True
+                    task_group = add_commit_refresh(obj=task_group, db=db)
+                    logger.info("END")
+
+                    reset_logger_handlers(logger)
+
+                except Exception as reactivate_e:
+                    # Delete corrupted source_dir
+                    try:
+                        logger.info(f"Now delete folder {source_dir}")
+                        fractal_ssh.remove_folder(
+                            folder=source_dir,
+                            safe_root=tasks_base_dir,
+                        )
+                        logger.info(f"Deleted folder {source_dir}")
+                    except Exception as rm_e:
+                        logger.error(
+                            "Removing folder failed. "
+                            f"Original error: {str(rm_e)}"
+                        )
+
+                    fail_and_cleanup(
+                        task_group=task_group,
+                        task_group_activity=activity,
+                        logger_name=LOGGER_NAME,
+                        log_file_path=log_file_path,
+                        exception=reactivate_e,
+                        db=db,
+                    )

fractal_server/tasks/v2/templates/pixi_1_extract.sh

@@ -0,0 +1,40 @@
+set -e
+
+write_log(){
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "[extract-tar-gz-pixi, ${TIMESTAMP}] ${1}"
+}
+
+# Replacements
+PACKAGE_DIR="__PACKAGE_DIR__"
+TAR_GZ_PATH="__TAR_GZ_PATH__"
+SOURCE_DIR_NAME="__SOURCE_DIR_NAME__"
+
+# Strip trailing `/` from `PACKAGE_DIR`
+PACKAGE_DIR=${PACKAGE_DIR%/}
+
+# Known paths
+SOURCE_DIR="${PACKAGE_DIR}/${SOURCE_DIR_NAME}"
+TAR_GZ_BASENAME=$(basename "${TAR_GZ_PATH}" ".tar.gz")
+
+TIME_START=$(date +%s)
+
+cd "${PACKAGE_DIR}"
+write_log "Changed working directory to ${PACKAGE_DIR}"
+
+# -----------------------------------------------------------------------------
+
+write_log "START 'tar xz -f ${TAR_GZ_PATH} ${TAR_GZ_BASENAME}'"
+tar xz -f "${TAR_GZ_PATH}" "${TAR_GZ_BASENAME}"
+write_log "END   'tar xz -f ${TAR_GZ_PATH} ${TAR_GZ_BASENAME}'"
+echo
+
+write_log "START 'mv ${PACKAGE_DIR}/${TAR_GZ_BASENAME} ${SOURCE_DIR}'"
+mv "${PACKAGE_DIR}/${TAR_GZ_BASENAME}" "${SOURCE_DIR}"
+write_log "END   'mv ${PACKAGE_DIR}/${TAR_GZ_BASENAME} ${SOURCE_DIR}'"
+echo
+
+TIME_END=$(date +%s)
+write_log "Elapsed: $((TIME_END - TIME_START)) seconds"
+write_log "All ok, exit."
+echo

fractal_server/tasks/v2/templates/pixi_2_install.sh

@@ -0,0 +1,52 @@
+set -e
+
+write_log(){
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "[install-tasks-pixi, ${TIMESTAMP}] ${1}"
+}
+
+# Replacements
+PIXI_HOME="__PIXI_HOME__"
+PACKAGE_DIR="__PACKAGE_DIR__"
+SOURCE_DIR_NAME="__SOURCE_DIR_NAME__"
+FROZEN_OPTION="__FROZEN_OPTION__"
+TOKIO_WORKER_THREADS="__TOKIO_WORKER_THREADS__"
+PIXI_CONCURRENT_SOLVES="__PIXI_CONCURRENT_SOLVES__"
+PIXI_CONCURRENT_DOWNLOADS="__PIXI_CONCURRENT_DOWNLOADS__"
+
+# Strip trailing `/` from `PACKAGE_DIR`
+PIXI_HOME=${PIXI_HOME%/}
+PACKAGE_DIR=${PACKAGE_DIR%/}
+
+# Known paths
+PIXI_EXECUTABLE="${PIXI_HOME}/bin/pixi"
+SOURCE_DIR="${PACKAGE_DIR}/${SOURCE_DIR_NAME}"
+PYPROJECT_TOML="${SOURCE_DIR}/pyproject.toml"
+
+# Pixi env variable
+export PIXI_HOME="${PIXI_HOME}"
+export PIXI_CACHE_DIR="${PIXI_HOME}/cache"
+export RATTLER_AUTH_FILE="${PIXI_HOME}/credentials.json"
+export TOKIO_WORKER_THREADS="${TOKIO_WORKER_THREADS}"
+
+TIME_START=$(date +%s)
+
+write_log "Hostname: $(hostname)"
+
+cd "${PACKAGE_DIR}"
+write_log "Changed working directory to ${PACKAGE_DIR}"
+
+# -----------------------------------------------------------------------------
+
+write_log "START '${PIXI_EXECUTABLE} install ${FROZEN_OPTION} --manifest-path ${PYPROJECT_TOML}'"
+${PIXI_EXECUTABLE} install \
+    --concurrent-solves "${PIXI_CONCURRENT_SOLVES}" \
+    --concurrent-downloads "${PIXI_CONCURRENT_DOWNLOADS}" \
+    ${FROZEN_OPTION} --manifest-path "${PYPROJECT_TOML}"
+write_log "END   '${PIXI_EXECUTABLE} install ${FROZEN_OPTION} --manifest-path ${PYPROJECT_TOML}'"
+echo
+
+TIME_END=$(date +%s)
+write_log "Elapsed: $((TIME_END - TIME_START)) seconds"
+write_log "All ok, exit."
+echo

fractal_server/tasks/v2/templates/pixi_3_post_install.sh

@@ -0,0 +1,76 @@
+set -e
+
+write_log(){
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "[after-install-pixi, ${TIMESTAMP}] ${1}"
+}
+
+# Replacements
+PIXI_HOME="__PIXI_HOME__"
+PACKAGE_DIR="__PACKAGE_DIR__"
+SOURCE_DIR_NAME="__SOURCE_DIR_NAME__"
+IMPORT_PACKAGE_NAME="__IMPORT_PACKAGE_NAME__"
+
+# Strip trailing `/` from `PACKAGE_DIR`
+PIXI_HOME=${PIXI_HOME%/}
+PACKAGE_DIR=${PACKAGE_DIR%/}
+
+# Known paths
+PIXI_EXECUTABLE="${PIXI_HOME}/bin/pixi"
+SOURCE_DIR="${PACKAGE_DIR}/${SOURCE_DIR_NAME}"
+PYPROJECT_TOML="${SOURCE_DIR}/pyproject.toml"
+ACTIVATION_FILE="${SOURCE_DIR}/activate_project.sh"
+PROJECT_PYTHON_WRAPPER="${SOURCE_DIR}/project_python.sh"
+
+# Pixi env variable
+export PIXI_HOME="${PIXI_HOME}"
+export PIXI_CACHE_DIR="${PIXI_HOME}/cache"
+export RATTLER_AUTH_FILE="${PIXI_HOME}/credentials.json"
+
+
+TIME_START=$(date +%s)
+
+cd "${PACKAGE_DIR}"
+write_log "Changed working directory to ${PACKAGE_DIR}"
+
+# -----------------------------------------------------------------------------
+
+write_log "START '${PIXI_EXECUTABLE} shell-hook --manifest-path ${PYPROJECT_TOML}'"
+${PIXI_EXECUTABLE} shell-hook --manifest-path "${PYPROJECT_TOML}" > "${ACTIVATION_FILE}"
+write_log "END   '${PIXI_EXECUTABLE} shell-hook --manifest-path ${PYPROJECT_TOML}'"
+echo
+
+PROJECT_PYTHON_BIN=$(${PIXI_EXECUTABLE} run --manifest-path "${PYPROJECT_TOML}" which python)
+write_log "Found PROJECT_PYTHON_BIN=${PROJECT_PYTHON_BIN}"
+
+# Write project-scoped Python wrapper
+cat <<EOF > "${PROJECT_PYTHON_WRAPPER}"
+#!/bin/bash
+source ${ACTIVATION_FILE}
+${PROJECT_PYTHON_BIN} "\$@"
+EOF
+
+chmod 755 "${PROJECT_PYTHON_WRAPPER}"
+write_log "Written ${PROJECT_PYTHON_WRAPPER} with 755 permissions"
+write_log "Project Python wrapper: ${PROJECT_PYTHON_WRAPPER}"
+write_log "Project-Python version: $(${PROJECT_PYTHON_WRAPPER} --version)"
+echo
+
+# Find PACKAGE_FOLDER
+FIND_PACKAGE_FOLDER_SCRIPT="${SOURCE_DIR}/find_package_folder.sh"
+echo "source ${ACTIVATION_FILE}" > "${FIND_PACKAGE_FOLDER_SCRIPT}"
+echo "${PROJECT_PYTHON_BIN} -c \"import ${IMPORT_PACKAGE_NAME} as p, os; print(os.path.dirname(p.__file__))\"" >> "${FIND_PACKAGE_FOLDER_SCRIPT}"
+PACKAGE_FOLDER=$(bash "${FIND_PACKAGE_FOLDER_SCRIPT}")
+write_log "Package folder: ${PACKAGE_FOLDER}"
+echo
+
+ENV_DISK_USAGE=$(du -sk "${PACKAGE_DIR}" | cut -f1)
+ENV_FILE_NUMBER=$(find "${PACKAGE_DIR}" -type f | wc -l)
+write_log "Disk usage: ${ENV_DISK_USAGE}"
+write_log "Number of files: ${ENV_FILE_NUMBER}"
+echo
+
+TIME_END=$(date +%s)
+write_log "Elapsed: $((TIME_END - TIME_START)) seconds"
+write_log "All ok, exit."
+echo

fractal_server/tasks/v2/utils_background.py

@@ -1,3 +1,4 @@
+import logging
 from pathlib import Path
 from typing import TypeVar
 
@@ -9,6 +10,7 @@ from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2.manifest import ManifestV2
 from fractal_server.app.schemas.v2.task_group import TaskGroupActivityActionV2
+from fractal_server.exceptions import UnreachableBranchError
 from fractal_server.logger import get_logger
 from fractal_server.logger import reset_logger_handlers
 from fractal_server.utils import get_timestamp
@@ -23,6 +25,31 @@ def add_commit_refresh(*, obj: T, db: DBSyncSession) -> T:
     return obj
 
 
+def get_activity_and_task_group(
+    *,
+    task_group_activity_id: int,
+    task_group_id: int,
+    db: DBSyncSession,
+    logger_name: str,
+) -> tuple[bool, TaskGroupV2, TaskGroupActivityV2]:
+    task_group = db.get(TaskGroupV2, task_group_id)
+    activity = db.get(TaskGroupActivityV2, task_group_activity_id)
+    if activity is None or task_group is None:
+        logging.error(
+            "Cannot find database rows with "
+            f"{task_group_id=} and {task_group_activity_id=}:\n"
+            f"{task_group=}\n{activity=}. Exit."
+        )
+        return False, None, None
+
+    # Log some info about task group
+    logger = get_logger(logger_name=logger_name)
+    for key, value in task_group.model_dump(exclude={"env_info"}).items():
+        logger.debug(f"task_group.{key}: {value}")
+
+    return True, task_group, activity
+
+
 def fail_and_cleanup(
     task_group: TaskGroupV2,
     task_group_activity: TaskGroupActivityV2,
@@ -47,11 +74,12 @@ def fail_and_cleanup(
     reset_logger_handlers(logger)
 
 
-def _prepare_tasks_metadata(
+def prepare_tasks_metadata(
     *,
     package_manifest: ManifestV2,
-    python_bin: Path,
     package_root: Path,
+    python_bin: Path | None = None,
+    project_python_wrapper: Path | None = None,
     package_version: str | None = None,
 ) -> list[TaskCreateV2]:
     """
@@ -59,10 +87,22 @@ def _prepare_tasks_metadata(
 
     Args:
         package_manifest:
-        python_bin:
         package_root:
         package_version:
+        python_bin:
+        project_python_wrapper:
     """
+
+    if bool(project_python_wrapper is None) == bool(python_bin is None):
+        raise UnreachableBranchError(
+            f"Either {project_python_wrapper} or {python_bin} must be set."
+        )
+
+    if python_bin is not None:
+        actual_python = python_bin
+    else:
+        actual_python = project_python_wrapper
+
     task_list = []
     for _task in package_manifest.task_list:
         # Set non-command attributes
@@ -76,14 +116,16 @@ def _prepare_tasks_metadata(
         # Set command attributes
         if _task.executable_non_parallel is not None:
             non_parallel_path = package_root / _task.executable_non_parallel
-            task_attributes["command_non_parallel"] = (
-                f"{python_bin.as_posix()} " f"{non_parallel_path.as_posix()}"
+            cmd_non_parallel = (
+                f"{actual_python.as_posix()} {non_parallel_path.as_posix()}"
             )
+            task_attributes["command_non_parallel"] = cmd_non_parallel
         if _task.executable_parallel is not None:
             parallel_path = package_root / _task.executable_parallel
-            task_attributes[
-                "command_parallel"
-            ] = f"{python_bin.as_posix()} {parallel_path.as_posix()}"
+            cmd_parallel = (
+                f"{actual_python.as_posix()} {parallel_path.as_posix()}"
+            )
+            task_attributes["command_parallel"] = cmd_parallel
         # Create object
         task_obj = TaskCreateV2(
             **_task.model_dump(

fractal_server/tasks/v2/utils_pixi.py

@@ -0,0 +1,38 @@
+from typing import TypedDict
+
+SOURCE_DIR_NAME = "source_dir"
+
+
+class ParsedOutput(TypedDict):
+    package_root: str
+    venv_size: str
+    venv_file_number: str
+    project_python_wrapper: str
+
+
+def parse_collect_stdout(stdout: str) -> ParsedOutput:
+    """
+    Parse standard output of `pixi/1_collect.sh`
+    """
+    searches = [
+        ("Package folder:", "package_root"),
+        ("Disk usage:", "venv_size"),
+        ("Number of files:", "venv_file_number"),
+        ("Project Python wrapper:", "project_python_wrapper"),
+    ]
+    stdout_lines = stdout.splitlines()
+    attributes = dict()
+    for search, attribute_name in searches:
+        matching_lines = [_line for _line in stdout_lines if search in _line]
+        if len(matching_lines) == 0:
+            raise ValueError(f"String '{search}' not found in stdout.")
+        elif len(matching_lines) > 1:
+            raise ValueError(
+                f"String '{search}' found too many times "
+                f"({len(matching_lines)})."
+            )
+        else:
+            actual_line = matching_lines[0]
+            attribute_value = actual_line.split(search)[-1].strip(" ")
+            attributes[attribute_name] = attribute_value
+    return attributes

fractal_server/tasks/v2/utils_templates.py

@@ -12,10 +12,21 @@ SCRIPTS_SUBFOLDER = "scripts"
 logger = set_logger(__name__)
 
 
+def _check_pixi_frozen_option(replacements: list[tuple[str, str]]):
+    try:
+        replacement = next(
+            rep for rep in replacements if rep[0] == "__FROZEN_OPTION__"
+        )
+        if replacement[1] not in ["", "--frozen"]:
+            raise ValueError(f"Invalid {replacement=}.")
+    except StopIteration:
+        pass
+
+
 def customize_template(
     *,
     template_name: str,
-    replacements: list[tuple[str, str]],
+    replacements: set[tuple[str, str]],
     script_path: str,
 ) -> str:
     """
@@ -26,6 +37,8 @@ def customize_template(
         replacements: List of replacements for template customization.
         script_path: Local path where the customized template will be written.
     """
+    _check_pixi_frozen_option(replacements=replacements)
+
     # Read template
     template_path = TEMPLATES_DIR / template_name
     with template_path.open("r") as f: