octopi 1.0__py3-none-any.whl

octopi/datasets/mixup.py

@@ -0,0 +1,49 @@
+from monai.transforms import Transform
+from torch.distributions import Beta
+from torch import nn
+import numpy as np
+import torch
+
+class MixupTransformd(Transform):
+    """
+    A dictionary-based wrapper for Mixup augmentation that applies to batches.
+    This needs to be applied after batching, typically directly in the training loop.
+    """
+    def __init__(self, keys=("image", "label"), mix_beta=0.2, mixadd=False, prob=0.5):
+        self.keys = keys
+        self.mixup = Mixup(mix_beta=mix_beta, mixadd=mixadd)
+        self.prob = prob
+        
+    def __call__(self, data):
+        d = dict(data)
+        if np.random.random() < self.prob:  # Apply with probability
+            d[self.keys[0]], d[self.keys[1]] = self.mixup(d[self.keys[0]], d[self.keys[1]])
+        return d
+
+class Mixup(nn.Module):
+    def __init__(self, mix_beta, mixadd=False):
+
+        super(Mixup, self).__init__()
+        self.beta_distribution = Beta(mix_beta, mix_beta)
+        self.mixadd = mixadd
+
+    def forward(self, X, Y, Z=None):
+
+        bs = X.shape[0]
+        n_dims = len(X.shape)
+        perm = torch.randperm(bs)
+        coeffs = self.beta_distribution.rsample(torch.Size((bs,))).to(X.device)
+        X_coeffs = coeffs.view((-1,) + (1,)*(X.ndim-1))
+        Y_coeffs = coeffs.view((-1,) + (1,)*(Y.ndim-1))
+        
+        X = X_coeffs * X + (1-X_coeffs) * X[perm]
+
+        if self.mixadd:
+            Y = (Y + Y[perm]).clip(0, 1)
+        else:
+            Y = Y_coeffs * Y + (1 - Y_coeffs) * Y[perm]
+                
+        if Z:
+            return X, Y, Z
+
+        return X, Y

octopi/datasets/multi_config_generator.py

@@ -0,0 +1,253 @@
+from octopi.datasets import dataset, augment, cached_datset
+from octopi.datasets.generators import TrainLoaderManager
+from monai.data import DataLoader, SmartCacheDataset, CacheDataset, Dataset
+from octopi import io
+import multiprocess as mp
+from typing import List
+from tqdm import tqdm
+import torch, gc
+
+class MultiConfigTrainLoaderManager(TrainLoaderManager):
+
+    def __init__(self, 
+                 configs: dict,  # Dictionary of session names and config paths
+                 target_name: str,
+                 target_session_id: str = None,
+                 target_user_id: str = None,
+                 voxel_size: float = 10, 
+                 tomo_algorithm: List[str] = ['wbp'], 
+                 tomo_batch_size: int = 15, 
+                 Nclasses: int = 3):
+        """
+        Initialize MultiConfigTrainLoaderManager with multiple configs.
+
+        Args:
+            configs (list): List of config file paths.
+            Other arguments are inherited from TrainLoaderManager.
+        """
+
+        # Initialize shared attributes manually (skip super().__init__ to avoid invalid config handling)
+        self.config = configs
+        self.roots = {name: io.load_copick_config(path) for name, path in configs.items()}
+
+        # Target and algorithm parameters
+        self.target_name = target_name
+        self.target_session_id = target_session_id
+        self.target_user_id = target_user_id
+        self.voxel_size = voxel_size
+        self.tomo_algorithm = tomo_algorithm
+
+        # Data management parameters
+        self.Nclasses = Nclasses
+        self.tomo_batch_size = tomo_batch_size
+        self.reload_training_dataset = True
+        self.reload_validation_dataset = True
+        self.val_loader = None
+        self.train_loader = None
+
+        # Initialize Run IDs placeholder
+        self.myRunIDs = {}
+
+        # Initialize the input dimensions   
+        self.nx = None
+        self.ny = None
+        self.nz = None        
+
+    def get_available_runIDs(self):
+        """
+        Identify and return a combined list of run IDs with available segmentations 
+        across all configured CoPick projects.
+
+        Returns:
+            List of tuples: [(session_name, run_name), ...]
+        """
+        available_runIDs = []  
+        for name, root in self.roots.items():
+            runIDs = [run.name for run in root.runs]                       
+            for run in runIDs:
+                run = root.get_run(run)
+                seg = run.get_segmentations(
+                    name=self.target_name, 
+                    session_id=self.target_session_id, 
+                    user_id=self.target_user_id,
+                    voxel_size=float(self.voxel_size)
+                )
+                if len(seg) > 0:
+                    available_runIDs.append((name, run.name))  # Include session name for disambiguation
+
+        # If No Segmentations are Found, Inform the User
+        if len(available_runIDs) == 0:
+            print(
+                f"[Error] No segmentations found for the target query:\n"
+                f"TargetName: {self.target_name}, UserID: {self.target_user_id}, "
+                f"SessionID: {self.target_session_id}\n"
+                f"Please check the target name, user ID, and session ID.\n"
+            )
+            exit()
+
+        return available_runIDs        
+
+    def get_data_splits(self, 
+                        trainRunIDs: str = None,
+                        validateRunIDs: str = None,
+                        train_ratio: float = 0.8,
+                        val_ratio: float = 0.1,
+                        test_ratio: float = 0.1,
+                        create_test_dataset: bool = True):
+        """
+        Override to handle run IDs as (session_name, run_name) tuples.
+        """
+        # Use the get_available_runIDs method to handle multiple projects
+        runIDs = self.get_available_runIDs()
+        return super().get_data_splits(trainRunIDs = runIDs, 
+                                       train_ratio = train_ratio, 
+                                       val_ratio = val_ratio, 
+                                       test_ratio = test_ratio, 
+                                       create_test_dataset = create_test_dataset)
+
+    def _initialize_train_iterators(self):
+        """
+        Initialize the training data iterators with multi-config support.
+        """
+        self.padded_train_list = self._get_padded_list(self.myRunIDs['train'], self.train_batch_size)
+        self.train_data_iter = iter(self._get_data_batches(self.padded_train_list, self.train_batch_size))
+
+    def _initialize_val_iterators(self):
+        """
+        Initialize the validation data iterators with multi-config support.
+        """
+        self.padded_val_list = self._get_padded_list(self.myRunIDs['validate'], self.val_batch_size)
+        self.val_data_iter = iter(self._get_data_batches(self.padded_val_list, self.val_batch_size))
+
+    def _load_data(self, runIDs):
+        """
+        Load data from multiple CoPick projects for given run IDs.
+
+        Args:
+            runIDs (list): List of (session_name, run_name) tuples.
+
+        Returns:
+            List: Combined dataset for the specified run IDs.
+        """
+
+        data = []
+        for session_name, run_name in tqdm(runIDs):
+            root = self.roots[session_name]
+            data.extend(io.load_training_data(
+                root, [run_name], self.voxel_size, self.tomo_algorithm, 
+                self.target_name, self.target_session_id, self.target_user_id, 
+                progress_update=False ))
+        self._check_max_label_value(data)
+        return data
+
+    def create_train_dataloaders(self, *args, **kwargs):
+        """
+        Override data loading to fetch from multiple projects.
+        """
+        my_crop_size = kwargs.get("crop_size", 96)
+        my_num_samples = kwargs.get("num_samples", 128)
+
+        # If reloads are disabled and loaders already exist, reuse them
+        if self.reload_frequency < 0 and (self.train_loader is not None) and (self.val_loader is not None):
+            return self.train_loader, self.val_loader        
+
+        # Estimate Max Number of Threads with mp.cpu_count
+        n_procs = min(mp.cpu_count(), 4)               
+
+        if self.train_loader is None: 
+            # Fetch the next batch of run IDs
+            trainRunIDs = self._extract_run_ids('train_data_iter', self._initialize_train_iterators)
+            train_files = self._load_data(trainRunIDs)
+
+            # # Create the cached dataset with non-random transforms
+            train_ds = SmartCacheDataset(data=train_files, transform=augment.get_transforms(), cache_rate=0.5)
+
+            # # Delete the training files to free memory
+            train_files = None
+            gc.collect()
+
+            # Create the cached dataset with non-random transforms
+            # train_ds = cached_datset.MultiConfigCacheDataset(
+            #     self, trainRunIDs, transform=augment.get_transforms(), cache_rate=1.0
+            # )
+
+            # I need to read (nx,ny,nz) and scale the crop size to make sure it isnt larger than nx.
+            if self.nx is None: (self.nx,self.ny,self.nz) = train_ds[0]['image'].shape[1:]
+            self.input_dim = io.get_input_dimensions(train_ds, my_crop_size)
+
+            # Wrap the cached dataset to apply random transforms during iteration
+            self.dynamic_train_dataset = dataset.DynamicDataset(
+                data=train_ds, 
+                transform=augment.get_random_transforms(self.input_dim, my_num_samples, self.Nclasses)
+            ) 
+
+            self.train_loader = DataLoader(
+                self.dynamic_train_dataset,
+                batch_size=1,
+                shuffle=True,
+                num_workers=n_procs,
+                pin_memory=torch.cuda.is_available(),             
+            )
+
+        else:
+            # Fetch the next batch of run IDs
+            trainRunIDs = self._extract_run_ids('train_data_iter', self._initialize_train_iterators)
+            train_files = self._load_data(trainRunIDs)
+            train_ds = CacheDataset(data=train_files, transform=augment.get_transforms(), cache_rate=1.0)
+            self.dynamic_train_dataset.update_data(train_ds)
+
+        # We Only Need to Reload the Validation Dataset if the Total Number of Runs is larger than 
+        # the tomo batch size
+        if self.val_loader is None: 
+
+            validateRunIDs = self._extract_run_ids('val_data_iter', self._initialize_val_iterators)             
+            val_files  = self._load_data(validateRunIDs)    
+
+            # # Create validation dataset
+            val_ds = SmartCacheDataset(data=val_files, transform=augment.get_transforms(), cache_rate=1.0)            
+
+            # # Delete the validation files to free memory
+            val_files = None
+            gc.collect()
+
+            # Create the cached dataset with non-random transforms
+            # val_ds = cached_datset.MultiConfigCacheDataset(
+            #     self, validateRunIDs, transform=augment.get_transforms(), cache_rate=1.0
+            # )
+
+            # # I need to read (nx,ny,nz) and scale the crop size to make sure it isnt larger than nx.
+            # if self.nx is None:
+            #     (self.nx,self.ny,self.nz) = val_ds[0]['image'].shape[1:]
+
+            # if crop_size > self.nx: self.input_dim = (self.nx, crop_size, crop_size)
+            # else:                   self.input_dim = (crop_size, crop_size, crop_size)
+
+            # Wrap the cached dataset to apply random transforms during iteration
+            self.dynamic_validation_dataset = dataset.DynamicDataset( data=val_ds )
+
+            # Create validation DataLoader
+            self.val_loader  = DataLoader(
+                self.dynamic_validation_dataset,
+                batch_size=1,
+                num_workers=n_procs,
+                pin_memory=torch.cuda.is_available(),
+                shuffle=False,  # Ensure the data order remains consistent            
+            )
+        else:
+            validateRunIDs = self._extract_run_ids('val_data_iter', self._initialize_val_iterators)             
+            val_files   = self._load_data(validateRunIDs)
+
+            val_ds = CacheDataset(data=val_files, transform=augment.get_transforms(), cache_rate=1.0)
+            self.dynamic_validation_dataset.update_data(val_ds)
+            
+        return self.train_loader, self.val_loader
+
+
+    def tmp_return_datasets(self):
+        trainRunIDs = self._extract_run_ids('train_data_iter', self._initialize_train_iterators)
+        train_files = self._load_data(trainRunIDs)   
+
+        validateRunIDs = self._extract_run_ids('val_data_iter', self._initialize_val_iterators)
+        val_files = self._load_data(validateRunIDs)
+
+        return train_files, val_files        

octopi/entry_points/common.py

@@ -0,0 +1,80 @@
+from octopi import utils
+import argparse
+
+def add_model_parameters(parser, octopi = False):
+    """
+    Add common model parameters to the parser.
+    """
+    
+    # Add U-Net model parameters
+    parser.add_argument("--Nclass", type=int, required=False, default=3, help="Number of prediction classes in the model")
+    parser.add_argument("--channels", type=utils.parse_int_list, required=False, default='32,64,128,128', help="List of channel sizes")
+    parser.add_argument("--strides", type=utils.parse_int_list, required=False, default='2,2,1', help="List of stride sizes")
+    parser.add_argument("--res-units", type=int, required=False, default=2, help="Number of residual units in the UNet")
+    parser.add_argument("--dim-in", type=int, required=False, default=96, help="Input dimension for the UNet model")
+
+def inference_model_parameters(parser):
+    """
+    Add model parameters for inference.
+    """
+    parser.add_argument("--model-config", type=str, required=True, help="Path to the model configuration file")
+    parser.add_argument("--model-weights", type=str, required=True, help="Path to the model weights file")
+
+def add_train_parameters(parser, octopi = False):
+    """
+    Add training parameters to the parser.
+    """
+    parser.add_argument("--num-epochs", type=int, required=False, default=100, help="Number of training epochs")
+    parser.add_argument("--val-interval", type=int, required=False, default=10, help="Interval for validation metric calculations")
+    parser.add_argument("--tomo-batch-size", type=int, required=False, default=15, help="Number of tomograms to load per epoch for training")
+    parser.add_argument("--best-metric", type=str, default='avg_f1', required=False, help="Metric to Monitor for Determining Best Model. To track fBetaN, use fBetaN with N as the beta-value.")
+    
+    if not octopi:
+        parser.add_argument("--num-tomo-crops", type=int, required=False, default=16, help="Number of tomogram crops to use per patch")    
+        parser.add_argument("--lr", type=float, required=False, default=1e-3, help="Learning rate for the optimizer")
+        parser.add_argument("--tversky-alpha", type=float, required=False, default=0.5, help="Alpha parameter for the Tversky loss")
+        parser.add_argument("--model-save-path", required=True, help="Path to model save directory")
+    else:
+        parser.add_argument("--num-trials", type=int, default=10, required=False, help="Number of trials for architecture search (default: 10).")
+
+            
+def add_config(parser, single_config):
+    if single_config:
+        parser.add_argument("--config", type=str, required=True, help="Path to the configuration file.")
+    else:
+        parser.add_argument("--config", type=str, required=True, action='append',
+                            help="Specify a single configuration path (/path/to/config.json) "
+                                 "or multiple entries in the format session_name,/path/to/config.json. "
+                                 "Use multiple --config entries for multiple sessions.")
+    parser.add_argument("--voxel-size", type=float, required=False, default=10, help="Voxel size of tomograms used")
+
+def add_inference_parameters(parser):
+
+    parser.add_argument("--tomo-alg", required=False, default = 'wbp', 
+                        help="Tomogram algorithm used for produces segmentation prediction masks.")    
+    parser.add_argument("--seg-info", type=utils.parse_target, required=False, 
+                        default='predict,octopi,1', help='Information Query to save Segmentation predictions under, e.g., (e.g., "name" or "name,user_id,session_id" - Default UserID is octopi and SessionID is 1')
+    parser.add_argument("--tomo-batch-size", type=int, default=25, required=False, 
+                        help="Batch size for tomogram processing.")
+    parser.add_argument("--run-ids", type=utils.parse_list, default=None, required=False, 
+                        help="List of run IDs for prediction, e.g., run1,run2 or [run1,run2]. If not provided, all available runs will be processed.")   
+    
+def add_localize_parameters(parser):
+
+    parser.add_argument("--voxel-size", type=int, required=False, default=10, help="Voxel size")
+    parser.add_argument("--method", type=str,required=False, default='watershed', help="Localization method")
+    parser.add_argument("--pick-session-id", required=False, default="1", type=str, help="Pick session ID")
+    parser.add_argument("--pick-objects", required=True, type=str, help="Pick objects")
+    parser.add_argument("--seg-info", required=True, type=str, help="Segmentation info")
+
+def add_slurm_parameters(parser, base_job_name, gpus = 1):
+    """
+    Add SLURM job parameters to the parser.
+    """
+    parser.add_argument("--conda-env", type=str, required=False, default='/hpc/projects/group.czii/conda_environments/pyUNET/', help="Path to Conda environment")
+    parser.add_argument("--job-name", type=str, required=False, default=f'{base_job_name}', help="Job name for SLURM job")        
+
+    if gpus > 0:
+        parser.add_argument("--gpu-constraint", type=str.lower, choices=['a6000', 'a100', 'h100', 'h200'], required=False, default='h100', help="GPU constraint")
+    if gpus > 1:
+        parser.add_argument("--num-gpus", type=int, required=False, default=1, help="Number of GPUs to use")

octopi/entry_points/create_slurm_submission.py

@@ -0,0 +1,243 @@
+from octopi.entry_points import run_train, run_segment_predict, run_localize, run_optuna
+from octopi.submit_slurm import create_shellsubmit, create_multiconfig_shellsubmit
+from octopi.processing.importers import cli_mrcs_parser, cli_dataportal_parser
+from octopi.entry_points import common 
+from octopi import utils
+import argparse
+
+def create_train_script(args):
+    """
+    Create a SLURM script for training 3D CNN models
+    """
+
+    strconfigs = ""
+    for config in args.config:
+        strconfigs += f"--config {config}"
+
+    command = f"""
+octopi train \\
+    --model-save-path {args.model_save_path} \\
+    --target-info {args.target_info} \\
+    --voxel-size {args.voxel_size} --tomo-algorithm {args.tomo_algorithm} --Nclass {args.Nclass} \\
+    --best-metric {args.best_metric} --num-epochs {args.num_epochs} --val-interval {args.val_interval} \\
+    --tomo-batch-size {args.tomo_batch_size} --num-tomo-crops {args.num_tomo_crops} \\
+    {strconfigs}
+"""
+
+    # If a model config is provided, use it to build the model
+    if args.model_config is not None:
+        command += f" --model-config {args.model_config}"
+    else:
+        command += f" --tversky-alpha {args.tversky_alpha} --channels {args.channels} --strides {args.strides} --dim-in {args.dim_in} --res-units {args.res_units}"
+
+    # If Model Weights are provided, use them to initialize the model
+    if args.model_weights is not None and args.model_config is not None:
+        command += f" --model-weights {args.model_weights}"
+
+    create_shellsubmit(
+        job_name = args.job_name,
+        output_file = 'trainer.log',
+        shell_name = 'train_octopi.sh',
+        conda_path = args.conda_env,
+        command = command,
+        num_gpus = 1,
+        gpu_constraint = args.gpu_constraint
+    )
+
+def train_model_slurm():
+    """
+    Create a SLURM script for training 3D CNN models
+    """
+    parser_description = "Create a SLURM script for training 3D CNN models"
+    args = run_train.train_model_parser(parser_description, add_slurm=True)
+    create_train_script(args)   
+
+def create_model_explore_script(args):
+    """
+    Create a SLURM script for running bayesian optimization on 3D CNN models
+    """
+    strconfigs = ""
+    for config in args.config:
+        strconfigs += f"--config {config}"
+
+    command = f"""
+octopi model-explore \\
+    --model-type {args.model_type} --model-save-path {args.model_save_path} \\
+    --voxel-size {args.voxel_size} --tomo-alg {args.tomo_alg} --Nclass {args.Nclass} \\
+    --val-interval {args.val_interval} --num-epochs {args.num_epochs} --num-trials {args.num_trials} \\
+    --best-metric {args.best_metric} --mlflow-experiment-name {args.mlflow_experiment_name} \\
+    --target-name {args.target_name} --target-session-id {args.target_session_id} --target-user-id {args.target_user_id} \\
+    {strconfigs}
+"""
+
+    create_shellsubmit(
+        job_name = args.job_name,
+        output_file = 'optuna.log',
+        shell_name = 'model_explore.sh',
+        conda_path = args.conda_env,
+        command = command,
+        num_gpus = 1,
+        gpu_constraint = args.gpu_constraint
+    )
+
+def model_explore_slurm():
+    """
+    Create a SLURM script for running bayesian optimization on 3D CNN models
+    """
+    parser_description = "Create a SLURM script for running bayesian optimization on 3D CNN models"
+    args = run_optuna.optuna_parser(parser_description, add_slurm=True)
+    create_model_explore_script(args)   
+
+def create_inference_script(args):
+    """
+    Create a SLURM script for running inference on 3D CNN models
+    """
+
+    if len(args.config.split(',')) > 1:
+
+        create_multiconfig_shellsubmit(
+            job_name = args.job_name,
+            output_file = 'predict.log',
+            shell_name = 'segment.sh',
+            conda_path = args.conda_env,
+            base_inputs = args.base_inputs,
+            config_inputs = args.config_inputs,
+            command = args.command,
+            num_gpus = args.num_gpus,
+            gpu_constraint = args.gpu_constraint
+        )
+    else:
+
+        command = f"""
+octopi inference \\
+    --config {args.config} \\
+    --seg-info  {",".join(args.seg_info)} \\
+    --model-weights {args.model_weights} \\
+    --dim-in {args.dim_in} --res-units {args.res_units} \\
+    --model-type {args.model_type} --channels {",".join(map(str, args.channels))} --strides {",".join(map(str, args.strides))} \\
+    --voxel-size {args.voxel_size} --tomo-alg {args.tomo_alg} --Nclass {args.Nclass}
+"""
+
+        create_shellsubmit(
+            job_name = args.job_name,
+            output_file = 'predict.log',
+            shell_name = 'segment.sh',
+            conda_path = args.conda_env,
+            command = command,
+            num_gpus = 1,
+            gpu_constraint = args.gpu_constraint
+        )
+
+def inference_slurm():
+    """
+    Create a SLURM script for running segmentation predictions with a specified model and configuration on CryoET Tomograms.
+    """
+    parser_description = "Create a SLURM script for running segmentation predictions with a specified model and configuration on CryoET Tomograms."
+    args = run_segment_predict.inference_parser(parser_description, add_slurm=True)
+    create_inference_script(args)
+
+def create_localize_script(args):
+    """"
+    Create a SLURM script for running localization on predicted segmentation masks
+    """
+    if len(args.config.split(',')) > 1:
+    
+        create_multiconfig_shellsubmit(
+            job_name = args.job_name,
+            output_file = args.output,
+            shell_name = args.output_script,
+            conda_path = args.conda_env,
+            base_inputs = args.base_inputs,
+            config_inputs = args.config_inputs,
+            command = args.command
+        )
+    else:
+
+        command = f"""
+octopi localize \\
+    --config {args.config} \\
+    --voxel-size {args.voxel_size} --pick-session-id {args.pick_session_id} --pick-user-id {args.pick_user_id} \\
+    --method {args.method}  --seg-info {",".join(args.seg_info)} \\
+"""
+        if args.pick_objects is not None:
+            command += f" --pick-objects {args.pick_objects}"
+
+        create_shellsubmit(
+            job_name = args.job_name,
+            output_file = 'localize.log',
+            shell_name = 'localize.sh',
+            conda_path = args.conda_env,
+            command = command,
+            num_gpus = 0
+        )
+
+def localize_slurm():
+    """
+    Create a SLURM script for running localization on predicted segmentation masks
+    """
+    parser_description = "Create a SLURM script for localization on predicted segmentation masks"
+    args = run_localize.localize_parser(parser_description, add_slurm=True)
+    create_localize_script(args)
+        
+def create_extract_mb_picks_script(args):
+    pass
+
+def extract_mb_picks_slurm():
+    pass
+
+
+def create_import_mrc_script(args):
+    """
+    Create a SLURM script for importing mrc volumes and potentialy downsampling
+    """
+    command = f"""
+octopi import-mrc-volumes \\
+    --mrcs-path {args.mrcs_path} \\
+    --config {args.config} --target-tomo-type {args.target_tomo_type} \\
+    --input-voxel-size {args.input_voxel_size} --output-voxel-size {args.output_voxel_size}
+"""
+
+    create_shellsubmit(
+        job_name = args.job_name,
+        output_file = 'importer.log',
+        shell_name = 'mrc_importer.sh',
+        conda_path = args.conda_env,
+        command = command
+    )
+
+def import_mrc_slurm():
+    """
+    Create a SLURM script for importing mrc volumes and potentialy downsampling
+    """
+    parser_description = "Create a SLURM script for importing mrc volumes and potentialy downsampling"
+    args = cli_mrcs_parser(parser_description, add_slurm=True)
+    create_import_mrc_script(args)
+
+
+def create_download_dataportal_script(args):
+    """
+    Create a SLURM script for downloading tomograms from the Dataportal
+    """
+    command = f"""
+octopi download-dataportal \\
+    --config {args.config} --datasetID {args.datasetID} \\
+    --overlay-path {args.overlay_path} 
+    --dataportal-name {args.dataportal_name} --target-tomo-type {args.target_tomo_type} \\
+    --input-voxel-size {args.input_voxel_size} --output-voxel-size {args.output_voxel_size}
+"""
+
+    create_shellsubmit(
+        job_name = args.job_name,
+        output_file = 'importer.log',
+        shell_name = 'dataportal_importer.sh',
+        conda_path = args.conda_env,
+        command = command
+    )
+
+def download_dataportal_slurm():
+    """
+    Create a SLURM script for downloading tomograms from the Dataportal
+    """
+    parser_description = "Create a SLURM script for downloading tomograms from the Dataportal"
+    args = cli_dataportal_parser(parser_description, add_slurm=True)
+    create_download_dataportal_script(args)