fractal-server 2.9.0a10__tar.gz → 2.9.0a12__tar.gz

{fractal_server-2.9.0a10 → fractal_server-2.9.0a12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.9.0a10
+Version: 2.9.0a12
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause
@@ -13,12 +13,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
-Requires-Dist: bcrypt (==4.0.1)
 Requires-Dist: cloudpickle (>=3.0.0,<3.1.0)
 Requires-Dist: clusterfutures (>=0.5,<0.6)
 Requires-Dist: fabric (>=3.2.2,<4.0.0)
 Requires-Dist: fastapi (>=0.115.0,<0.116.0)
-Requires-Dist: fastapi-users[oauth] (>=12.1.0,<13.0.0)
+Requires-Dist: fastapi-users[oauth] (>=14,<15)
 Requires-Dist: gunicorn (>=21.2,<23.0)
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: psutil (>=5.9.8,<6.0.0)

fractal_server-2.9.0a12/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.9.0a12"

{fractal_server-2.9.0a10 → fractal_server-2.9.0a12}/fractal_server/app/routes/auth/group.py

@@ -10,6 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
 from . import current_active_superuser
+from ._aux_auth import _get_default_usergroup_id
 from ._aux_auth import _get_single_usergroup_with_user_ids
 from ._aux_auth import _user_or_404
 from ._aux_auth import _usergroup_or_404
@@ -234,16 +235,35 @@ async def remove_user_from_group(
     superuser: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> UserGroupRead:
+
+    # Check that user and group exist
     await _usergroup_or_404(group_id, db)
     user = await _user_or_404(user_id, db)
+
+    # Check that group is not the default one
+    default_user_group_id = await _get_default_usergroup_id(db=db)
+    if default_user_group_id == group_id:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot remove user from '{FRACTAL_DEFAULT_GROUP_NAME}' "
+                "group.",
+            ),
+        )
+
     link = await db.get(LinkUserGroup, (group_id, user_id))
     if link is None:
+        # If user and group are not linked, fail
         raise HTTPException(
             status_code=422,
             detail=f"User '{user.email}' is not a member of group {group_id}.",
         )
     else:
+        # If user and group are linked, delete the link
         await db.delete(link)
         await db.commit()
+
+    # Enrich the response object with user_ids
     group = await _get_single_usergroup_with_user_ids(group_id=group_id, db=db)
+
     return group

{fractal_server-2.9.0a10 → fractal_server-2.9.0a12}/fractal_server/app/routes/auth/users.py

@@ -8,9 +8,7 @@ from fastapi import status
 from fastapi_users import exceptions
 from fastapi_users import schemas
 from fastapi_users.router.common import ErrorCode
-from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import col
 from sqlmodel import func
 from sqlmodel import select
 
@@ -18,9 +16,10 @@ from . import current_active_superuser
 from ...db import get_async_db
 from ...schemas.user import UserRead
 from ...schemas.user import UserUpdate
-from ...schemas.user import UserUpdateWithNewGroupIds
 from ..aux.validate_user_settings import verify_user_has_settings
+from ._aux_auth import _get_default_usergroup_id
 from ._aux_auth import _get_single_user_with_groups
+from ._aux_auth import FRACTAL_DEFAULT_GROUP_NAME
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
@@ -28,6 +27,7 @@ from fractal_server.app.models import UserSettings
 from fractal_server.app.routes.auth._aux_auth import _user_or_404
 from fractal_server.app.schemas import UserSettingsRead
 from fractal_server.app.schemas import UserSettingsUpdate
+from fractal_server.app.schemas.user import UserUpdateGroups
 from fractal_server.app.security import get_user_manager
 from fractal_server.app.security import UserManager
 from fractal_server.logger import set_logger
@@ -55,114 +55,43 @@ async def get_user(
 @router_users.patch("/users/{user_id}/", response_model=UserRead)
 async def patch_user(
     user_id: int,
-    user_update: UserUpdateWithNewGroupIds,
+    user_update: UserUpdate,
     current_superuser: UserOAuth = Depends(current_active_superuser),
     user_manager: UserManager = Depends(get_user_manager),
     db: AsyncSession = Depends(get_async_db),
 ):
     """
     Custom version of the PATCH-user route from `fastapi-users`.
-
-    In order to keep the fastapi-users logic in place (which is convenient to
-    update user attributes), we split the endpoint into two branches. We either
-    go through the fastapi-users-based attribute-update branch, or through the
-    branch where we establish new user/group relationships.
-
-    Note that we prevent making both changes at the same time, since it would
-    be more complex to guarantee that endpoint error would leave the database
-    in the same state as before the API call.
     """
 
-    # We prevent simultaneous editing of both user attributes and user/group
-    # associations
-    user_update_dict_without_groups = user_update.dict(
-        exclude_unset=True, exclude={"new_group_ids"}
-    )
-    edit_attributes = user_update_dict_without_groups != {}
-    edit_groups = user_update.new_group_ids is not None
-    if edit_attributes and edit_groups:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                "Cannot modify both user attributes and group membership. "
-                "Please make two independent PATCH calls"
-            ),
-        )
-
     # Check that user exists
     user_to_patch = await _user_or_404(user_id, db)
 
-    if edit_groups:
-        # Establish new user/group relationships
-
-        # Check that all required groups exist
-        # Note: The reason for introducing `col` is as in
-        # https://sqlmodel.tiangolo.com/tutorial/where/#type-annotations-and-errors,
-        stm = select(func.count()).where(
-            col(UserGroup.id).in_(user_update.new_group_ids)
+    # Modify user attributes
+    try:
+        user = await user_manager.update(
+            user_update,
+            user_to_patch,
+            safe=False,
+            request=None,
+        )
+        validated_user = schemas.model_validate(UserOAuth, user)
+        patched_user = await db.get(
+            UserOAuth, validated_user.id, populate_existing=True
+        )
+    except exceptions.InvalidPasswordException as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
+                "reason": e.reason,
+            },
+        )
+    except exceptions.UserAlreadyExists:
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST,
+            detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
         )
-        res = await db.execute(stm)
-        number_matching_groups = res.scalar()
-        if number_matching_groups != len(user_update.new_group_ids):
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=(
-                    "Not all requested groups (IDs: "
-                    f"{user_update.new_group_ids}) exist."
-                ),
-            )
-
-        for new_group_id in user_update.new_group_ids:
-            link = LinkUserGroup(user_id=user_id, group_id=new_group_id)
-            db.add(link)
-
-        try:
-            await db.commit()
-        except IntegrityError as e:
-            error_msg = (
-                f"Cannot link groups with IDs {user_update.new_group_ids} "
-                f"to user {user_id}. "
-                "Likely reason: one of these links already exists.\n"
-                f"Original error: {str(e)}"
-            )
-            logger.info(error_msg)
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=error_msg,
-            )
-        patched_user = user_to_patch
-    elif edit_attributes:
-        # Modify user attributes
-        try:
-            user_update_without_groups = UserUpdate(
-                **user_update_dict_without_groups
-            )
-            user = await user_manager.update(
-                user_update_without_groups,
-                user_to_patch,
-                safe=False,
-                request=None,
-            )
-            validated_user = schemas.model_validate(UserOAuth, user)
-            patched_user = await db.get(
-                UserOAuth, validated_user.id, populate_existing=True
-            )
-        except exceptions.InvalidPasswordException as e:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail={
-                    "code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
-                    "reason": e.reason,
-                },
-            )
-        except exceptions.UserAlreadyExists:
-            raise HTTPException(
-                status.HTTP_400_BAD_REQUEST,
-                detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
-            )
-    else:
-        # Nothing to do, just continue
-        patched_user = user_to_patch
 
     # Enrich user object with `group_ids_names` attribute
     patched_user_with_groups = await _get_single_user_with_groups(
@@ -203,6 +132,75 @@ async def list_users(
     return user_list
 
 
+@router_users.post("/users/{user_id}/set-groups/", response_model=UserRead)
+async def set_user_groups(
+    user_id: int,
+    user_update: UserUpdateGroups,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> UserRead:
+
+    # Preliminary check that all objects exist in the db
+    user = await _user_or_404(user_id=user_id, db=db)
+    target_group_ids = user_update.group_ids
+    stm = select(func.count(UserGroup.id)).where(
+        UserGroup.id.in_(target_group_ids)
+    )
+    res = await db.execute(stm)
+    count = res.scalar()
+    if count != len(target_group_ids):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Some UserGroups in {target_group_ids} do not exist.",
+        )
+
+    # Check that default group is not being removed
+    default_group_id = await _get_default_usergroup_id(db=db)
+    if default_group_id not in target_group_ids:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot remove user from "
+                f"'{FRACTAL_DEFAULT_GROUP_NAME}' group.",
+            ),
+        )
+
+    # Prepare lists of links to be removed
+    res = await db.execute(
+        select(LinkUserGroup)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.not_in(target_group_ids))
+    )
+    links_to_remove = res.scalars().all()
+
+    # Prepare lists of links to be added
+    res = await db.execute(
+        select(LinkUserGroup.group_id)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.in_(target_group_ids))
+    )
+    ids_links_already_in = res.scalars().all()
+    ids_links_to_add = set(target_group_ids) - set(ids_links_already_in)
+
+    # Remove/create links as needed
+    for link in links_to_remove:
+        logger.info(
+            f"Removing LinkUserGroup with {link.user_id=} "
+            f"and {link.group_id=}."
+        )
+        await db.delete(link)
+    for group_id in ids_links_to_add:
+        logger.info(
+            f"Creating new LinkUserGroup with {user_id=} " f"and {group_id=}."
+        )
+        db.add(LinkUserGroup(user_id=user_id, group_id=group_id))
+    await db.commit()
+
+    user_with_groups = await _get_single_user_with_groups(user, db)
+
+    return user_with_groups
+
+
 @router_users.get(
     "/users/{user_id}/settings/", response_model=UserSettingsRead
 )

{fractal_server-2.9.0a10 → fractal_server-2.9.0a12}/fractal_server/app/runner/executors/slurm/_slurm_config.py

@@ -456,20 +456,3 @@ def _parse_mem_value(raw_mem: Union[str, int]) -> int:
 
     logger.debug(f"{info}, return {mem_MB}")
     return mem_MB
-
-
-def get_default_slurm_config():
-    """
-    Return a default `SlurmConfig` configuration object
-    """
-    return SlurmConfig(
-        partition="main",
-        cpus_per_task=1,
-        mem_per_task_MB=100,
-        target_cpus_per_job=1,
-        max_cpus_per_job=2,
-        target_mem_per_job=100,
-        max_mem_per_job=500,
-        target_num_jobs=2,
-        max_num_jobs=4,
-    )

{fractal_server-2.9.0a10 → fractal_server-2.9.0a12}/fractal_server/app/runner/executors/slurm/ssh/executor.py

@@ -31,9 +31,11 @@ from ....filenames import SHUTDOWN_FILENAME
 from ....task_files import get_task_file_paths
 from ....task_files import TaskFiles
 from ....versions import get_versions
-from ...slurm._slurm_config import get_default_slurm_config
 from ...slurm._slurm_config import SlurmConfig
 from .._batching import heuristics
+from ..utils_executors import get_pickle_file_path
+from ..utils_executors import get_slurm_file_path
+from ..utils_executors import get_slurm_script_file_path
 from ._executor_wait_thread import FractalSlurmWaitThread
 from fractal_server.app.runner.components import _COMPONENT_KEY_
 from fractal_server.app.runner.compress_folder import compress_folder
@@ -223,132 +225,12 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         with self.jobs_lock:
             self.map_jobid_to_slurm_files_local.pop(jobid)
 
-    def get_input_pickle_file_path_local(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-
-        prefix = prefix or "cfut"
-        output = (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_in_{arg}.pickle"
-        )
-        return output
-
-    def get_input_pickle_file_path_remote(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-
-        prefix = prefix or "cfut"
-        output = (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_in_{arg}.pickle"
-        )
-        return output
-
-    def get_output_pickle_file_path_local(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "cfut"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_out_{arg}.pickle"
-        )
-
-    def get_output_pickle_file_path_remote(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "cfut"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_out_{arg}.pickle"
-        )
-
-    def get_slurm_script_file_path_local(
-        self, *, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "_temp"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_submit.sbatch"
-        )
-
-    def get_slurm_script_file_path_remote(
-        self, *, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "_temp"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_submit.sbatch"
-        )
-
-    def get_slurm_stdout_file_path_local(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stdout"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.out"
-        )
-
-    def get_slurm_stdout_file_path_remote(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stdout"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.out"
-        )
-
-    def get_slurm_stderr_file_path_local(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stderr"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.err"
-        )
-
-    def get_slurm_stderr_file_path_remote(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stderr"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.err"
-        )
-
     def submit(
         self,
         fun: Callable[..., Any],
         *fun_args: Sequence[Any],
-        slurm_config: Optional[SlurmConfig] = None,
-        task_files: Optional[TaskFiles] = None,
+        slurm_config: SlurmConfig,
+        task_files: TaskFiles,
         **fun_kwargs: dict,
     ) -> Future:
         """
@@ -359,11 +241,9 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             fun_args: Function positional arguments
             fun_kwargs: Function keyword arguments
             slurm_config:
-                A `SlurmConfig` object; if `None`, use
-                `get_default_slurm_config()`.
+                A `SlurmConfig` object.
             task_files:
-                A `TaskFiles` object; if `None`, use
-                `self.get_default_task_files()`.
+                A `TaskFiles` object.
 
         Returns:
             Future representing the execution of the current SLURM job.
@@ -375,12 +255,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             logger.warning(error_msg)
             raise JobExecutionError(info=error_msg)
 
-        # Set defaults, if needed
-        if slurm_config is None:
-            slurm_config = get_default_slurm_config()
-        if task_files is None:
-            task_files = self.get_default_task_files()
-
         # Set slurm_file_prefix
         slurm_file_prefix = task_files.file_prefix
 
@@ -418,8 +292,8 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         fn: Callable[..., Any],
         iterable: list[Sequence[Any]],
         *,
-        slurm_config: Optional[SlurmConfig] = None,
-        task_files: Optional[TaskFiles] = None,
+        slurm_config: SlurmConfig,
+        task_files: TaskFiles,
     ):
         """
         Return an iterator with the results of several execution of a function
@@ -442,12 +316,9 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 An iterable such that each element is the list of arguments to
                 be passed to `fn`, as in `fn(*args)`.
             slurm_config:
-                A `SlurmConfig` object; if `None`, use
-                `get_default_slurm_config()`.
+                A `SlurmConfig` object.
             task_files:
-                A `TaskFiles` object; if `None`, use
-                `self.get_default_task_files()`.
-
+                A `TaskFiles` object.
         """
 
         # Do not continue if auxiliary thread was shut down
@@ -472,12 +343,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 # self._exception
                 del fut
 
-        # Set defaults, if needed
-        if not slurm_config:
-            slurm_config = get_default_slurm_config()
-        if task_files is None:
-            task_files = self.get_default_task_files()
-
         # Include common_script_lines in extra_lines
         logger.debug(
             f"Adding {self.common_script_lines=} to "
@@ -710,63 +575,80 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 f"Missing folder {subfolder_path.as_posix()}."
             )
 
-        # Define I/O pickle file local/remote paths
         job.input_pickle_files_local = tuple(
-            self.get_input_pickle_file_path_local(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_local,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="in",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
+
         job.input_pickle_files_remote = tuple(
-            self.get_input_pickle_file_path_remote(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_remote,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="in",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
         job.output_pickle_files_local = tuple(
-            self.get_output_pickle_file_path_local(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_local,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="out",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
         job.output_pickle_files_remote = tuple(
-            self.get_output_pickle_file_path_remote(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_remote,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="out",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
-
-        # Define SLURM-job file local/remote paths
-        job.slurm_script_local = self.get_slurm_script_file_path_local(
+        # define slurm-job file local/remote paths
+        job.slurm_script_local = get_slurm_script_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_script_remote = self.get_slurm_script_file_path_remote(
+        job.slurm_script_remote = get_slurm_script_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stdout_local = self.get_slurm_stdout_file_path_local(
+        job.slurm_stdout_local = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="out",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stdout_remote = self.get_slurm_stdout_file_path_remote(
+        job.slurm_stdout_remote = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="out",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stderr_local = self.get_slurm_stderr_file_path_local(
+        job.slurm_stderr_local = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="err",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stderr_remote = self.get_slurm_stderr_file_path_remote(
+        job.slurm_stderr_remote = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="err",
             prefix=job.slurm_file_prefix,
         )
 
@@ -1294,7 +1176,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         slurm_err_path: str,
         slurm_config: SlurmConfig,
     ):
-
         num_tasks_max_running = slurm_config.parallel_tasks_per_job
         mem_per_task_MB = slurm_config.mem_per_task_MB
 
@@ -1346,19 +1227,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         script = "\n".join(script_lines)
         return script
 
-    def get_default_task_files(self) -> TaskFiles:
-        """
-        This will be called when self.submit or self.map are called from
-        outside fractal-server, and then lack some optional arguments.
-        """
-        task_files = TaskFiles(
-            workflow_dir_local=self.workflow_dir_local,
-            workflow_dir_remote=self.workflow_dir_remote,
-            task_order=None,
-            task_name="name",
-        )
-        return task_files
-
     def shutdown(self, wait=True, *, cancel_futures=False):
         """
         Clean up all executor variables. Note that this function is executed on