fractal-server 2.8.1__py3-none-any.whl → 2.9.0__py3-none-any.whl

fractal_server/tasks/v2/ssh/reactivate.py

@@ -0,0 +1,202 @@
+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_templates import get_collection_replacements
+from ._utils import _customize_and_run_template
+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 set_logger
+from fractal_server.ssh._fabric import FractalSSH
+from fractal_server.tasks.utils import get_log_path
+from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.tasks.v2.utils_python_interpreter import (
+    get_python_interpreter_v2,
+)
+from fractal_server.tasks.v2.utils_templates import SCRIPTS_SUBFOLDER
+from fractal_server.utils import get_timestamp
+
+LOGGER_NAME = __name__
+
+
+def reactivate_ssh(
+    *,
+    task_group_activity_id: int,
+    task_group_id: int,
+    fractal_ssh: FractalSSH,
+    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:
+        fractal_ssh:
+        tasks_base_dir:
+            Only used as a `safe_root` in `remove_dir`, and typically set to
+            `user_settings.ssh_tasks_dir`.
+    """
+
+    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,
+        )
+
+        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.debug("START")
+            for key, value in task_group.model_dump().items():
+                logger.debug(f"task_group.{key}: {value}")
+
+            # Check that SSH connection works
+            try:
+                fractal_ssh.check_connection()
+            except Exception as e:
+                logger.error("Cannot establish SSH connection.")
+                fail_and_cleanup(
+                    task_group=task_group,
+                    task_group_activity=activity,
+                    logger_name=LOGGER_NAME,
+                    log_file_path=log_file_path,
+                    exception=e,
+                    db=db,
+                )
+                return
+
+            # Check that the (remote) task_group venv_path does not exist
+            if fractal_ssh.remote_exists(task_group.venv_path):
+                error_msg = f"{task_group.venv_path} 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
+
+            try:
+                activity.status = TaskGroupActivityStatusV2.ONGOING
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Prepare replacements for templates
+                replacements = get_collection_replacements(
+                    task_group=task_group,
+                    python_bin=get_python_interpreter_v2(
+                        python_version=task_group.python_version
+                    ),
+                )
+
+                # Prepare replacements for templates
+                pip_freeze_file_local = f"{tmpdir}/pip_freeze.txt"
+                pip_freeze_file_remote = (
+                    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)
+                fractal_ssh.send_file(
+                    local=pip_freeze_file_local, remote=pip_freeze_file_remote
+                )
+                replacements.append(
+                    ("__PIP_FREEZE_FILE__", pip_freeze_file_remote)
+                )
+
+                # Define script_dir_remote and create it if missing
+                script_dir_remote = (
+                    Path(task_group.path) / SCRIPTS_SUBFOLDER
+                ).as_posix()
+                fractal_ssh.mkdir(folder=script_dir_remote, parents=True)
+
+                # Prepare common arguments for `_customize_and_run_template`
+                common_args = dict(
+                    replacements=replacements,
+                    script_dir_local=(
+                        Path(tmpdir) / SCRIPTS_SUBFOLDER
+                    ).as_posix(),
+                    script_dir_remote=script_dir_remote,
+                    prefix=(
+                        f"{int(time.time())}_"
+                        f"{TaskGroupActivityActionV2.REACTIVATE}"
+                    ),
+                    fractal_ssh=fractal_ssh,
+                    logger_name=LOGGER_NAME,
+                )
+
+                # Create remote directory for scripts
+                fractal_ssh.mkdir(folder=script_dir_remote)
+
+                logger.debug("start - create venv")
+                _customize_and_run_template(
+                    template_filename="1_create_venv.sh",
+                    **common_args,
+                )
+                logger.debug("end - create venv")
+                activity.log = get_current_log(log_file_path)
+                activity.timestamp_ended = get_timestamp()
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                logger.debug("start - install from pip freeze")
+                _customize_and_run_template(
+                    template_filename="6_pip_install_from_freeze.sh",
+                    **common_args,
+                )
+                logger.debug("end - install from pip freeze")
+                activity.log = get_current_log(log_file_path)
+                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.debug("END")
+
+            except Exception as reactivate_e:
+                # Delete corrupted venv_path
+                try:
+                    logger.info(f"Now delete folder {task_group.venv_path}")
+                    fractal_ssh.remove_folder(
+                        folder=task_group.venv_path,
+                        safe_root=tasks_base_dir,
+                    )
+                    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)}"
+                    )
+
+                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,
+                )
+        return

fractal_server/tasks/v2/templates/{_2_preliminary_pip_operations.sh → 1_create_venv.sh}

@@ -5,18 +5,17 @@ write_log(){
     echo "[collect-task, $TIMESTAMP] $1"
 }
 
+
 # Variables to be filled within fractal-server
 PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
+PYTHON=__PYTHON__
 
 TIME_START=$(date +%s)
 
-VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
-
-# Upgrade pip
-write_log "START upgrade pip"
-"$VENVPYTHON" -m pip install --no-cache-dir "pip<=__FRACTAL_MAX_PIP_VERSION__" --upgrade
-"$VENVPYTHON" -m pip install --no-cache-dir setuptools
-write_log "END   upgrade pip"
+# Create venv
+write_log "START create venv in ${PACKAGE_ENV_DIR}"
+"$PYTHON" -m venv "$PACKAGE_ENV_DIR" --copies
+write_log "END   create venv in ${PACKAGE_ENV_DIR}"
 echo
 
 # End

fractal_server/tasks/v2/templates/{_3_pip_install.sh → 2_pip_install.sh}

@@ -5,16 +5,23 @@ write_log(){
     echo "[collect-task, $TIMESTAMP] $1"
 }
 
-
 # Variables to be filled within fractal-server
 PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
 INSTALL_STRING=__INSTALL_STRING__
 PINNED_PACKAGE_LIST="__PINNED_PACKAGE_LIST__"
+FRACTAL_MAX_PIP_VERSION="__FRACTAL_MAX_PIP_VERSION__"
 
 TIME_START=$(date +%s)
 
 VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
 
+# Upgrade `pip` and install `setuptools`
+write_log "START upgrade pip and install setuptools"
+"$VENVPYTHON" -m pip install --no-cache-dir "pip<=${FRACTAL_MAX_PIP_VERSION}" --upgrade
+"$VENVPYTHON" -m pip install --no-cache-dir setuptools
+write_log "END   upgrade pip and install setuptools"
+echo
+
 # Install package
 write_log "START install ${INSTALL_STRING}"
 "$VENVPYTHON" -m pip install --no-cache-dir "$INSTALL_STRING"

fractal_server/tasks/v2/templates/{_4_pip_freeze.sh → 3_pip_freeze.sh}

@@ -1,12 +1,5 @@
 set -e
 
-write_log(){
-    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-    echo "[collect-task, $TIMESTAMP] $1"
-}
-
-
-
 # Variables to be filled within fractal-server
 PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
 

fractal_server/tasks/v2/templates/{_5_pip_show.sh → 4_pip_show.sh}

@@ -11,7 +11,6 @@ PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
 PACKAGE_NAME=__PACKAGE_NAME__
 
 
-
 TIME_START=$(date +%s)
 
 VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
@@ -38,16 +37,16 @@ echo
 MANIFEST_RELATIVE_PATH=$($VENVPYTHON -m pip show "$PACKAGE_NAME" --files | grep "__FRACTAL_MANIFEST__.json" | tr -d "[:space:]")
 write_log "Manifest relative path: $MANIFEST_RELATIVE_PATH"
 echo
-MANIFEST_ABSOLUTE_PATH="${PACKAGE_PARENT_FOLDER}/${MANIFEST_RELATIVE_PATH}"
-write_log "Manifest absolute path: $MANIFEST_ABSOLUTE_PATH"
-echo
-if [ -f "$MANIFEST_ABSOLUTE_PATH" ]; then
+if [ "$MANIFEST_RELATIVE_PATH" != "" ]; then
     write_log "OK: manifest path exists"
     echo
 else
-    write_log "ERROR: manifest path not found at $MANIFEST_ABSOLUTE_PATH"
+    write_log "ERROR: manifest path not found for $PACKAGE_NAME"
     exit 2
 fi
+MANIFEST_ABSOLUTE_PATH="${PACKAGE_PARENT_FOLDER}/${MANIFEST_RELATIVE_PATH}"
+write_log "Manifest absolute path: $MANIFEST_ABSOLUTE_PATH"
+echo
 
 # End
 TIME_END=$(date +%s)

fractal_server/tasks/v2/templates/5_get_venv_size_and_file_number.sh

@@ -0,0 +1,10 @@
+set -e
+
+# Variables to be filled within fractal-server
+PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
+
+# Find memory usage and file number
+ENV_DISK_USAGE=$(du -sk "${PACKAGE_ENV_DIR}" | cut -f1)
+ENV_FILE_NUMBER=$(find "${PACKAGE_ENV_DIR}" -type f | wc -l)
+
+echo $ENV_DISK_USAGE $ENV_FILE_NUMBER

fractal_server/tasks/v2/templates/6_pip_install_from_freeze.sh

@@ -0,0 +1,35 @@
+set -e
+
+write_log(){
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "[collect-task, $TIMESTAMP] $1"
+}
+
+# Variables to be filled within fractal-server
+PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
+PIP_FREEZE_FILE=__PIP_FREEZE_FILE__
+FRACTAL_MAX_PIP_VERSION=__FRACTAL_MAX_PIP_VERSION__
+
+TIME_START=$(date +%s)
+
+VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
+
+# Upgrade `pip` and install `setuptools`
+write_log "START upgrade pip and install setuptools"
+"$VENVPYTHON" -m pip install --no-cache-dir "pip<=${FRACTAL_MAX_PIP_VERSION}" --upgrade
+"$VENVPYTHON" -m pip install --no-cache-dir setuptools
+write_log "END   upgrade pip and install setuptools"
+echo
+
+# Install from pip-freeze file
+write_log "START installing requirements from ${PIP_FREEZE_FILE}"
+"$VENVPYTHON" -m pip install -r "${PIP_FREEZE_FILE}"
+write_log "END   installing requirements from ${PIP_FREEZE_FILE}"
+echo
+
+# End
+TIME_END=$(date +%s)
+write_log "All good up to here."
+write_log "Elapsed: $((TIME_END - TIME_START)) seconds"
+write_log "Exit."
+echo

fractal_server/tasks/v2/utils_background.py

@@ -1,121 +1,70 @@
 from pathlib import Path
 from typing import Optional
+from typing import TypeVar
 
 from sqlalchemy.orm import Session as DBSyncSession
-from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 
-from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
-from fractal_server.app.schemas.v2 import CollectionStatusV2
 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.logger import get_logger
 from fractal_server.logger import reset_logger_handlers
+from fractal_server.utils import get_timestamp
 
+T = TypeVar("T")
 
-def _set_collection_state_data_status(
-    *,
-    state_id: int,
-    new_status: CollectionStatusV2,
-    logger_name: str,
-    db: DBSyncSession,
-):
-    logger = get_logger(logger_name)
-    logger.debug(f"{state_id=} - set state.data['status'] to {new_status}")
-    collection_state = db.get(CollectionStateV2, state_id)
-    collection_state.data["status"] = CollectionStatusV2(new_status)
-    flag_modified(collection_state, "data")
-    db.commit()
 
-
-def _set_collection_state_data_log(
-    *,
-    state_id: int,
-    new_log: str,
-    logger_name: str,
-    db: DBSyncSession,
-):
-    logger = get_logger(logger_name)
-    logger.debug(f"{state_id=} - set state.data['log']")
-    collection_state = db.get(CollectionStateV2, state_id)
-    collection_state.data["log"] = new_log
-    flag_modified(collection_state, "data")
-    db.commit()
-
-
-def _set_collection_state_data_info(
-    *,
-    state_id: int,
-    new_info: str,
-    logger_name: str,
-    db: DBSyncSession,
-):
-    logger = get_logger(logger_name)
-    logger.debug(f"{state_id=} - set state.data['info']")
-    collection_state = db.get(CollectionStateV2, state_id)
-    collection_state.data["info"] = new_info
-    flag_modified(collection_state, "data")
+def add_commit_refresh(*, obj: T, db: DBSyncSession) -> T:
+    db.add(obj)
     db.commit()
+    db.refresh(obj)
+    return obj
 
 
-def _handle_failure(
-    state_id: int,
+def fail_and_cleanup(
+    task_group: TaskGroupV2,
+    task_group_activity: TaskGroupActivityV2,
     logger_name: str,
     exception: Exception,
-    db: DBSyncSession,
-    task_group_id: int,
     log_file_path: Path,
+    db: DBSyncSession,
 ):
     logger = get_logger(logger_name)
-    logger.error(f"Task collection failed. Original error: {str(exception)}")
-
-    _set_collection_state_data_status(
-        state_id=state_id,
-        new_status=CollectionStatusV2.FAIL,
-        logger_name=logger_name,
-        db=db,
+    logger.error(
+        f"Task {task_group_activity.action} failed. "
+        f"Original error: {str(exception)}"
     )
 
-    new_log = log_file_path.open("r").read()
-
-    _set_collection_state_data_log(
-        state_id=state_id,
-        new_log=new_log,
-        logger_name=logger_name,
-        db=db,
-    )
-    # For backwards-compatibility, we also set state.data["info"]
-    _set_collection_state_data_info(
-        state_id=state_id,
-        new_info=f"Original error: {exception}",
-        logger_name=logger_name,
-        db=db,
-    )
+    task_group_activity.status = TaskGroupActivityStatusV2.FAILED
+    task_group_activity.timestamp_ended = get_timestamp()
+    task_group_activity.log = get_current_log(log_file_path)
+    task_group_activity = add_commit_refresh(obj=task_group_activity, db=db)
+    if task_group_activity.action == TaskGroupActivityActionV2.COLLECT:
+        logger.info(f"Now delete TaskGroupV2 with {task_group.id=}")
 
-    # Delete TaskGroupV2 object / and apply cascade operation to FKs
-    logger.info(f"Now delete TaskGroupV2 with {task_group_id=}")
-    logger.info("Start of CollectionStateV2 cascade operations.")
-    stm = select(CollectionStateV2).where(
-        CollectionStateV2.taskgroupv2_id == task_group_id
-    )
-    res = db.execute(stm)
-    collection_states = res.scalars().all()
-    for collection_state in collection_states:
-        logger.info(
-            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
-            "to None."
+        logger.info("Start of TaskGroupActivityV2 cascade operations.")
+        stm = select(TaskGroupActivityV2).where(
+            TaskGroupActivityV2.taskgroupv2_id == task_group.id
         )
-        collection_state.taskgroupv2_id = None
-        db.add(collection_state)
-    logger.info("End of CollectionStateV2 cascade operations.")
-    task_group = db.get(TaskGroupV2, task_group_id)
-    db.delete(task_group)
-    db.commit()
-    logger.info(f"TaskGroupV2 with {task_group_id=} deleted")
+        res = db.execute(stm)
+        task_group_activity_list = res.scalars().all()
+        for task_group_activity in task_group_activity_list:
+            logger.info(
+                f"Setting TaskGroupActivityV2[{task_group_activity.id}]"
+                ".taskgroupv2_id to None."
+            )
+            task_group_activity.taskgroupv2_id = None
+            db.add(task_group_activity)
+        logger.info("End of TaskGroupActivityV2 cascade operations.")
+        logger.info(f"TaskGroupV2 with {task_group.id=} deleted")
 
+        db.delete(task_group)
+    db.commit()
     reset_logger_handlers(logger)
-    return
 
 
 def _prepare_tasks_metadata(
@@ -170,40 +119,6 @@ def _prepare_tasks_metadata(
     return task_list
 
 
-def check_task_files_exist(task_list: list[TaskCreateV2]) -> None:
-    """
-    Check that the modules listed in task commands point to existing files.
-
-    Args:
-        task_list:
-    """
-    for _task in task_list:
-        if _task.command_non_parallel is not None:
-            _task_path = _task.command_non_parallel.split()[1]
-            if not Path(_task_path).exists():
-                raise FileNotFoundError(
-                    f"Task `{_task.name}` has `command_non_parallel` "
-                    f"pointing to missing file `{_task_path}`."
-                )
-        if _task.command_parallel is not None:
-            _task_path = _task.command_parallel.split()[1]
-            if not Path(_task_path).exists():
-                raise FileNotFoundError(
-                    f"Task `{_task.name}` has `command_parallel` "
-                    f"pointing to missing file `{_task_path}`."
-                )
-
-
-def _refresh_logs(
-    *,
-    state_id: int,
-    log_file_path: Path,
-    db: DBSyncSession,
-) -> None:
-    """
-    Read logs from file and update them in the db.
-    """
-    collection_state = db.get(CollectionStateV2, state_id)
-    collection_state.data["log"] = log_file_path.open("r").read()
-    flag_modified(collection_state, "data")
-    db.commit()
+def get_current_log(logger_file_path: str) -> str:
+    with open(logger_file_path, "r") as f:
+        return f.read()

fractal_server/tasks/v2/utils_templates.py

@@ -1,7 +1,13 @@
 from pathlib import Path
 
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
 TEMPLATES_DIR = Path(__file__).parent / "templates"
 
+SCRIPTS_SUBFOLDER = "scripts"
+
 
 def customize_template(
     *,
@@ -25,14 +31,16 @@ def customize_template(
     script_data = template_data
     for old_new in replacements:
         script_data = script_data.replace(old_new[0], old_new[1])
+    # Create parent folder if needed
+    Path(script_path).parent.mkdir(exist_ok=True)
     # Write script locally
     with open(script_path, "w") as f:
         f.write(script_data)
 
 
-def parse_script_5_stdout(stdout: str) -> dict[str, str]:
+def parse_script_pip_show_stdout(stdout: str) -> dict[str, str]:
     """
-    Parse standard output of template 5.
+    Parse standard output of 4_pip_show.sh
     """
     searches = [
         ("Python interpreter:", "python_bin"),
@@ -57,3 +65,25 @@ def parse_script_5_stdout(stdout: str) -> dict[str, str]:
             attribute_value = actual_line.split(search)[-1].strip(" ")
             attributes[attribute_name] = attribute_value
     return attributes
+
+
+def get_collection_replacements(
+    *, task_group: TaskGroupV2, python_bin: str
+) -> dict[str, str]:
+    settings = Inject(get_settings)
+
+    replacements = [
+        ("__PACKAGE_NAME__", task_group.pkg_name),
+        ("__PACKAGE_ENV_DIR__", task_group.venv_path),
+        ("__PYTHON__", python_bin),
+        ("__INSTALL_STRING__", task_group.pip_install_string),
+        (
+            "__FRACTAL_MAX_PIP_VERSION__",
+            settings.FRACTAL_MAX_PIP_VERSION,
+        ),
+        (
+            "__PINNED_PACKAGE_LIST__",
+            task_group.pinned_package_versions_string,
+        ),
+    ]
+    return replacements

fractal_server/utils.py

@@ -108,8 +108,10 @@ def execute_command_sync(
     stdout = res.stdout
     stderr = res.stderr
     logger.debug(f"{returncode=}")
-    logger.debug(f"{stdout=}")
-    logger.debug(f"{stderr=}")
+    logger.debug("STDOUT:")
+    logger.debug(stdout)
+    logger.debug("STDERR:")
+    logger.debug(stderr)
     if res.returncode != 0:
         logger.debug(f"ERROR in subprocess call to '{command}'")
         raise RuntimeError(

fractal_server/zip_tools.py

@@ -122,9 +122,26 @@ def _zip_folder_to_file_and_remove(folder: str) -> None:
     3. Checks if the folder can be safely deleted using the
         `_folder_can_be_deleted` function. If so, deletes the original folder.
     """
-    _create_zip(folder, f"{folder}_tmp.zip")
-    shutil.move(f"{folder}_tmp.zip", f"{folder}.zip")
+
+    tmp_zipfile = f"{folder}_tmp.zip"
+    zipfile = f"{folder}.zip"
+
+    try:
+        logger.info(f"Start creating temporary zip file at '{tmp_zipfile}'.")
+        _create_zip(folder, tmp_zipfile)
+        logger.info("Zip file created.")
+    except Exception as e:
+        logger.error(
+            f"Error while creating temporary zip file. Original error: '{e}'."
+        )
+        Path(tmp_zipfile).unlink(missing_ok=True)
+        return
+
+    logger.info(f"Moving temporary zip file to {zipfile}.")
+    shutil.move(tmp_zipfile, zipfile)
+    logger.info("Zip file moved.")
+
     if _folder_can_be_deleted(folder):
-        logger.info(f"Deleting folder '{folder}'...")
+        logger.info(f"Removing folder '{folder}'.")
         shutil.rmtree(folder)
-        logger.info(f"Deletion of folder '{folder}' completed.")
+        logger.info("Folder removed.")