idmtools-platform-slurm 0.0.0.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

idmtools_platform_slurm/assets/batch.sh.jinja2

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# Set the total number of tasks
+total_tasks={{njobs}}
+
+# Set the number of tasks per array job
+batch_size={{array_batch_size}}
+
+# Set max running jobs
+max_jobs={{max_running_jobs}}
+
+num_batches=$((total_tasks / batch_size))
+remainder=$((total_tasks % batch_size))
+
+echo "num_batches: $num_batches"
+echo "remainder: $remainder"
+
+# Submit the first array job with tasks 1-batch_size
+job_id=$(sbatch --array=1-$batch_size%$max_jobs sbatch.sh 0 | awk '{print $4}')
+echo $job_id >> job_id.txt
+
+# Submit additional array jobs that depend on the first job
+for (( i=1; i<$num_batches; i+=1 ))
+do
+    # Calculate the task range for the current array job
+    start_task=$((i * $batch_size))
+
+    # Submit the array job with the current task range and a dependency on the previous job
+    {% if dependency is defined and dependency %}
+        new_job_id=$(sbatch --array=1-$batch_size%$max_jobs --dependency=afterok:$job_id sbatch.sh $start_task | awk '{print $4}')
+    {% else %}
+        new_job_id=$(sbatch --array=1-$batch_size%$max_jobs sbatch.sh $start_task | awk '{print $4}')
+    {% endif %}
+    echo $new_job_id >> job_id.txt
+
+    # Update the job ID to use as a dependency for the next array job
+    job_id=$new_job_id
+done
+
+# Submit the remaining tasks as a separate batch
+if [ $remainder -gt 0 ]
+then
+    start_task=$(($num_batches * $batch_size))
+
+    # Submit the array job with the current task range and a dependency on the previous job
+    {% if dependency is defined and dependency %}
+        new_job_id=$(sbatch --array=1-$remainder%$max_jobs --dependency=afterok:$job_id sbatch.sh $start_task | awk '{print $4}')
+    {% else %}
+        new_job_id=$(sbatch --array=1-$remainder%$max_jobs sbatch.sh $start_task | awk '{print $4}')
+    {% endif %}
+    echo $new_job_id >> job_id.txt
+fi
+
+wait

idmtools_platform_slurm/assets/run_simulation.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# Get the parameters passed from sbatch.sh
+mpi_type="$2"
+
+SIMULATION_INDEX=$((${SLURM_ARRAY_TASK_ID} + $1))
+JOB_DIRECTORY=$(find . -type d -maxdepth 1 -mindepth 1  | grep -v Assets | head -$SIMULATION_INDEX | tail -1)
+cd $JOB_DIRECTORY
+current_dir=$(pwd)
+echo "The script is running from: $current_dir"
+
+# Run the simulation based on whether MPI is required
+if [ "$mpi_type" = "no-mpi" ]; then
+    echo "Run without MPI"
+    srun _run.sh 1> stdout.txt 2> stderr.txt
+elif [ "$mpi_type" = "mpirun" ]; then
+    echo "Run mpirun"
+    mpirun "$current_dir"/_run.sh 1> stdout.txt 2> stderr.txt
+elif [ "$mpi_type" = "pmi2" ] || [ "$mpi_type" = "pmix" ]; then # pmi2 or pmix
+    echo "Run MPI with $mpi_type"
+    srun --mpi=$mpi_type _run.sh 1> stdout.txt 2> stderr.txt
+else
+    echo "Invalid MPI type: $mpi_type"
+fi

idmtools_platform_slurm/assets/sbatch.sh.jinja2

@@ -0,0 +1,77 @@
+#!/bin/bash
+{% if ntasks is defined and ntasks is not none %}
+#SBATCH --ntasks={{ntasks}}
+{% endif %}
+{% if partition is defined and partition is not none %}
+#SBATCH --partition={{partition}}
+{% endif %}
+{% if nodes is defined and nodes is not none %}
+#SBATCH --nodes={{nodes}}
+{% endif %}
+{% if mail_type is defined and mail_type is not none %}
+#SBATCH --mail-type={{mail_type}}
+{% endif %}
+{% if mail_user is defined and mail_user is not none %}
+#SBATCH --mail-user={{mail_user}}
+{% endif %}
+{% if constraint is defined and constraint is not none %}
+#SBATCH --constraint={{constraint}}
+{% endif %}
+{% if ntasks_per_core is defined and ntasks_per_core  is not none %}
+#SBATCH --ntasks-per-core={{ntasks_per_core}}
+{% endif %}
+{% if cpus_per_task is defined and cpus_per_task  is not none %}
+#SBATCH --cpus-per-task={{cpus_per_task}}
+{% endif %}
+{% if mem_per_cpu is defined and mem_per_cpu is not none %}
+#SBATCH --mem-per-cpu={{mem_per_cpu}}
+{% endif %}
+{% if time is defined and time is not none %}
+#SBATCH --time={{time}}
+{% endif %}
+{% if account is defined and account is not none %}
+#SBATCH --account={{account}}
+{% endif %}
+{% if exclusive is defined and exclusive is not none and exclusive %}
+#SBATCH --exclusive
+{% endif %}
+{% if mem is defined and mem is not none %}
+#SBATCH --mem={{mem}}
+{% endif %}
+{% if requeue is defined and requeue is not none and requeue %}
+#SBATCH --requeue
+{% endif %}
+{% if sbatch_custom is defined and sbatch_custom is not none %}
+#SBATCH {{sbatch_custom}}
+{% endif %}
+#SBATCH --open-mode=append
+#SBATCH --output=stdout.txt
+#SBATCH --error=stderr.txt
+
+
+{% if modules is defined and modules is not none and modules|length > 0 %}
+{% for m in modules %}
+module load {{m}}
+{% endfor %}
+{% endif %}
+
+# Assign the values from the template
+ntasks={{ntasks|default(1)}}
+
+# Get mpi_type
+mpi_type={{mpi_type|lower}}
+
+# All submissions happen at the experiment level
+# Check if ntasks is greater than 1 to include --mpi=$mpi_type
+if [ "$ntasks" -gt 1 ]; then
+    echo "Running with MPI (ntasks=$ntasks)"
+    bash run_simulation.sh "$1" "$mpi_type"
+else
+    echo "Running without MPI (ntasks=$ntasks)"
+    bash run_simulation.sh "$1" "no-mpi"
+fi
+wait
+
+
+
+

idmtools_platform_slurm/cli/__init__.py

@@ -0,0 +1,4 @@
+"""idmtools comps cli module.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""

idmtools_platform_slurm/cli/slurm.py

@@ -0,0 +1,151 @@
+"""
+idmtools slurm cli commands.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import json
+import click
+from idmtools.core import ItemType
+from idmtools.core.platform_factory import Platform
+from idmtools_platform_slurm.utils.status_report.status_report import generate_status_report
+from idmtools_platform_slurm.utils.status_report.utils import get_latest_experiment, check_status
+from logging import getLogger
+
+logger = getLogger(__name__)
+user_logger = getLogger('user')
+
+
+@click.group(short_help="Slurm platform related commands.")
+@click.argument('job-directory')
+@click.pass_context
+def slurm(ctx: click.Context, job_directory):
+    """
+    Commands related to managing the SLURM platform.
+
+    job_directory: Slurm Working Directory
+    """
+    ctx.obj = dict(job_directory=job_directory)
+
+
+@slurm.command(help="Get simulation's report")
+@click.option('--suite-id', default=None, help="Idmtools Suite id")
+@click.option('--exp-id', default=None, help="Idmtools Experiment id")
+@click.option('--status-filter', type=click.Choice(['0', '-1', '100']), multiple=True, help="list of status")
+@click.option('--sim-filter', multiple=True, help="list of simulations")
+@click.option('--job-filter', multiple=True, help="list of slurm jobs")
+@click.option('--root', default='sim', type=click.Choice(['job', 'sim']), help="Dictionary root key")
+@click.option('--verbose/--no-verbose', default=True, help="Enable verbose output in results")
+@click.option('--display/--no-display', default=True, help="Display with working directory or not")
+@click.option('--display-count', default=20, help="Display Count")
+@click.pass_context
+def status_report(ctx: click.Context, suite_id, exp_id, status_filter, sim_filter, job_filter, root, verbose, display,
+                  display_count):
+    job_dir = ctx.obj['job_directory']
+
+    if suite_id is not None:
+        scope = (suite_id, ItemType.SUITE)
+    elif exp_id is not None:
+        scope = (exp_id, ItemType.EXPERIMENT)
+    else:
+        scope = None
+
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    generate_status_report(platform=platform, scope=scope,
+                           status_filter=status_filter if len(status_filter) > 0 else None,
+                           job_filter=job_filter if len(job_filter) > 0 else None,
+                           sim_filter=sim_filter if len(sim_filter) > 0 else None,
+                           root=root, verbose=verbose, display=display, display_count=display_count)
+
+
+@slurm.command(help="Get Suite/Experiment/Simulation directory")
+@click.option('--sim-id', default=None, help="Idmtools Simulation id")
+@click.option('--exp-id', default=None, help="Idmtools Experiment id")
+@click.option('--suite-id', default=None, help="Idmtools Suite id")
+@click.pass_context
+def get_path(ctx: click.Context, sim_id, exp_id, suite_id):
+    job_dir = ctx.obj['job_directory']
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    if sim_id is not None:
+        item_dir = platform.get_directory_by_id(sim_id, ItemType.SIMULATION)
+    elif exp_id is not None:
+        item_dir = platform.get_directory_by_id(exp_id, ItemType.EXPERIMENT)
+    elif suite_id is not None:
+        item_dir = platform.get_directory_by_id(suite_id, ItemType.SUITE)
+    else:
+        raise Exception('Must provide at least one: suite-id, exp-id or sim-id!')
+
+    user_logger.info(item_dir)
+
+
+@slurm.command(help="Get status of Experiment/Simulation")
+@click.option('--sim-id', default=None, help="Idmtools Simulation id")
+@click.option('--exp-id', default=None, help="Idmtools Experiment id")
+@click.pass_context
+def get_status(ctx: click.Context, sim_id, exp_id):
+    job_dir = ctx.obj['job_directory']
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    if sim_id is not None:
+        status = platform._op_client.get_simulation_status(sim_id)
+    elif exp_id is not None:
+        exp = platform.get_item(exp_id, ItemType.EXPERIMENT)
+        status = exp.status
+    else:
+        raise Exception('Must provide at least one: exp-id or sim-id!')
+
+    user_logger.info(status.name if status else None)
+
+
+@slurm.command(help="Get Suite/Experiment/Simulation slurm job")
+@click.option('--sim-id', default=None, help="Idmtools Simulation id")
+@click.option('--exp-id', default=None, help="Idmtools Experiment id")
+@click.option('--suite-id', default=None, help="Idmtools Suite id")
+@click.pass_context
+def get_job(ctx: click.Context, sim_id, exp_id, suite_id):
+    job_dir = ctx.obj['job_directory']
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    if sim_id is not None:
+        job_id = platform._op_client.get_job_id(sim_id, ItemType.SIMULATION)
+    elif exp_id is not None:
+        job_id = platform._op_client.get_job_id(exp_id, ItemType.EXPERIMENT)
+    elif suite_id is not None:
+        suite = platform.get_item(suite_id, ItemType.SUITE)
+        exp_id = suite.experiments[0].id
+        job_id = platform._op_client.get_job_id(exp_id, ItemType.EXPERIMENT)
+    else:
+        raise Exception('Must provide at least one: suite-id, exp-id or sim-id!')
+
+    user_logger.info(job_id)
+
+
+@slurm.command(help="Get the latest experiment info")
+@click.pass_context
+def get_latest(ctx: click.Context):
+    job_dir = ctx.obj['job_directory']
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    result = get_latest_experiment(platform)
+    user_logger.info(json.dumps(result, indent=3))
+
+
+@slurm.command(help="Get simulation's status")
+@click.option('--exp-id', default=None, help="Idmtools Experiment id")
+@click.option('--display/--no-display', default=False, help="Display with working directory or not")
+@click.pass_context
+def status(ctx: click.Context, exp_id, display):
+    """
+    Get job status.
+    Args:
+        ctx: click.Context
+        exp_id: experiment id
+        display: bool True/False
+    Returns:
+        None
+    """
+    job_dir = ctx.obj['job_directory']
+    platform = Platform('SLURM_LOCAL', job_directory=job_dir)
+
+    check_status(platform=platform, exp_id=exp_id, display=display)

idmtools_platform_slurm/platform_operations/asset_collection_operations.py

@@ -0,0 +1,25 @@
+"""
+Here we implement the SlurmPlatform asset collection operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+from dataclasses import dataclass
+from logging import getLogger
+from typing import TYPE_CHECKING
+from idmtools_platform_file.platform_operations.asset_collection_operations import FilePlatformAssetCollectionOperations
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+logger = getLogger(__name__)
+user_logger = getLogger("user")
+
+EXCLUDE_FILES = ['_run.sh', 'metadata.json', 'stdout.txt', 'stderr.txt', 'status.txt', 'job_id.txt', 'job_status.txt']
+
+
+@dataclass
+class SlurmPlatformAssetCollectionOperations(FilePlatformAssetCollectionOperations):
+    """
+    Provides AssetCollection Operations to SlurmPlatform.
+    """
+    platform: 'SlurmPlatform'  # noqa F821

idmtools_platform_slurm/platform_operations/experiment_operations.py

@@ -0,0 +1,107 @@
+"""
+Here we implement the SlurmPlatform experiment operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+import os
+from pathlib import Path
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from idmtools.core import EntityStatus
+from idmtools.core import ItemType
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_file.platform_operations.experiment_operations import FilePlatformExperimentOperations
+from logging import getLogger
+
+
+logger = getLogger(__name__)
+user_logger = getLogger('user')
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+
+@dataclass
+class SlurmPlatformExperimentOperations(FilePlatformExperimentOperations):
+    platform: 'SlurmPlatform'  # noqa: F821
+    RUN_SIMULATION_SCRIPT_PATH = Path(__file__).parent.parent.joinpath('assets/run_simulation.sh')
+
+    def platform_run_item(self, experiment: Experiment, dry_run: bool = False, **kwargs):
+        """
+        Run experiment.
+        Args:
+            experiment: idmtools Experiment
+            dry_run: True/False
+            kwargs: keyword arguments used to expand functionality
+        Returns:
+            None
+        """
+        # Ensure parent
+        super().platform_run_item(experiment, **kwargs)
+        # Commission
+        if not dry_run:
+            self.platform.submit_job(experiment, **kwargs)
+
+    def refresh_status(self, experiment: Experiment, **kwargs):
+        """
+        Refresh status of experiment.
+        Args:
+            experiment: idmtools Experiment
+            kwargs: keyword arguments used to expand functionality
+        Returns:
+            Dict of simulation id as key and working dir as value
+        """
+        # Check if file job_id.txt exists
+        job_id_path = self.platform.get_directory(experiment).joinpath('job_id.txt')
+        if not job_id_path.exists():
+            logger.debug(f'job_id is not available for experiment: {experiment.id}')
+            return
+
+        # Refresh status for each simulation
+        for sim in experiment.simulations:
+            sim.status = self.platform.get_simulation_status(sim.id, **kwargs)
+
+    def platform_cancel(self, experiment_id: str, force: bool = True) -> None:
+        """
+        Cancel platform experiment's slurm job.
+        Args:
+            experiment_id: experiment id
+            force: bool, True/False
+        Returns:
+            Any
+        """
+        experiment = self.platform.get_item(experiment_id, ItemType.EXPERIMENT, raw=False)
+        if force or experiment.status == EntityStatus.RUNNING:
+            logger.debug(f"cancel slurm job for experiment: {experiment_id}...")
+            job_id = self.platform.get_job_id(experiment_id, ItemType.EXPERIMENT)
+            if job_id is None:
+                logger.debug(f"Slurm job for experiment: {experiment_id} is not available!")
+            else:
+                result = self.platform._op_client.cancel_job(job_id)
+                user_logger.info(f"Cancel Experiment {experiment_id}: {result}")
+        else:
+            user_logger.info(f"Experiment {experiment_id} is not running, no cancel needed...")
+
+    def post_run_item(self, experiment: Experiment, **kwargs):
+        """
+        Trigger right after commissioning experiment on platform.
+
+        Args:
+            experiment: Experiment just commissioned
+            kwargs: keyword arguments used to expand functionality
+        Returns:
+            None
+        """
+        super().post_run_item(experiment, **kwargs)
+
+        job_ids = self.platform.get_job_id(experiment.id, ItemType.EXPERIMENT)
+        if job_ids is None:
+            logger.debug(f"Slurm job for experiment: {experiment.id} is not available!")
+            user_logger.info("Slurm Job Ids: None")
+        else:
+            job_ids = [f'{" ".ljust(3)}{id}' for id in job_ids]
+            user_logger.info(f"Slurm Job Ids ({len(job_ids)}):")
+            user_logger.info('\n'.join(job_ids))
+
+        user_logger.info(
+            f'\nYou may try the following command to check simulations running status: \n  idmtools slurm {os.path.abspath(self.platform.job_directory)} status --exp-id {experiment.id}')

idmtools_platform_slurm/platform_operations/json_metadata_operations.py

@@ -0,0 +1,17 @@
+"""
+Here we implement the SlurmPlatform experiment operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+from typing import TYPE_CHECKING
+from dataclasses import dataclass
+from idmtools_platform_file.platform_operations.json_metadata_operations import \
+    JSONMetadataOperations as FileJSONMetadataOperations
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+
+@dataclass
+class SlurmJSONMetadataOperations(FileJSONMetadataOperations):
+    platform: 'SlurmPlatform'  # noqa: F821

idmtools_platform_slurm/platform_operations/simulation_operations.py

@@ -0,0 +1,46 @@
+"""
+Here we implement the SlurmPlatform simulation operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from idmtools.core import ItemType, EntityStatus
+from idmtools_platform_file.platform_operations.simulation_operations import FilePlatformSimulationOperations
+from logging import getLogger
+
+logger = getLogger(__name__)
+user_logger = getLogger('user')
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class SlurmPlatformSimulationOperations(FilePlatformSimulationOperations):
+    platform: 'SlurmPlatform'  # noqa: F821
+
+    def platform_cancel(self, sim_id: str, force: bool = False) -> Any:
+        """
+        Cancel platform simulation's slurm job.
+        Args:
+            sim_id: simulation id
+            force: bool, True/False
+        Returns:
+            Any
+        """
+        sim = self.platform.get_item(sim_id, ItemType.SIMULATION, raw=False)
+        if force or sim.status == EntityStatus.RUNNING:
+            logger.debug(f"cancel slurm job for simulation: {sim_id}...")
+            job_id = self.platform.get_job_id(sim_id, ItemType.SIMULATION)
+            if job_id is None:
+                logger.debug(f"Slurm job for simulation: {sim_id} is not available!")
+                return
+            else:
+                result = self.platform._op_client.cancel_job(job_id)
+                user_logger.info(f"Cancel Simulation: {sim_id}: {result}")
+                return result
+        else:
+            user_logger.info(f"Simulation {sim_id} is not running, no cancel needed...")

idmtools_platform_slurm/platform_operations/suite_operations.py

@@ -0,0 +1,38 @@
+"""
+Here we implement the SlurmPlatform suite operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from logging import getLogger
+from idmtools.core import ItemType
+from idmtools_platform_file.platform_operations.suite_operations import FilePlatformSuiteOperations
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+logger = getLogger(__name__)
+user_logger = getLogger('user')
+
+
+@dataclass
+class SlurmPlatformSuiteOperations(FilePlatformSuiteOperations):
+    """
+    Provides Suite operation to the SlurmPlatform.
+    """
+    platform: 'SlurmPlatform'  # noqa F821
+
+    def platform_cancel(self, suite_id: str, force: bool = False) -> None:
+        """
+        Cancel platform suite's slurm job.
+        Args:
+            suite_id: suite id
+            force: bool, True/False
+        Returns:
+            None
+        """
+        suite = self.platform.get_item(suite_id, ItemType.SUITE, force=True, raw=False)
+        logger.debug(f"cancel slurm job for suite: {suite_id}...")
+        for exp in suite.experiments:
+            self.platform._experiments.platform_cancel(exp.id, force)

idmtools_platform_slurm/platform_operations/utils.py

@@ -0,0 +1,45 @@
+"""
+This is SlurmPlatform operations utils.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+import os
+import subprocess
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+
+def get_max_array_size():
+    """
+    Get Slurm MaxArraySize from configuration.
+    Returns:
+        Slurm system MaxArraySize
+    """
+    try:
+        output = subprocess.check_output(['scontrol', 'show', 'config'])
+        for line in output.decode().splitlines():
+            if line.startswith("MaxArraySize"):
+                max_array_size = int(line.split("=")[1])
+                return max_array_size - 1
+    except (subprocess.CalledProcessError, IndexError, ValueError):
+        pass
+
+    return None
+
+
+def check_home(directory: str) -> bool:
+    """
+    Check if a directory is under HOME.
+    Args:
+        directory: a directory
+
+    Returns:
+        True/False
+    """
+    home = os.path.expanduser("~").replace('\\', '/')
+    directory = directory.replace('\\', '/')
+    if directory.startswith(home):
+        return True
+    else:
+        return False

idmtools_platform_slurm/plugin_info.py

@@ -0,0 +1,75 @@
+"""
+idmtools slurm platform plugin definition.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+from pathlib import Path
+from typing import Type, Dict
+from idmtools.entities.iplatform import IPlatform
+from idmtools.registry.platform_specification import example_configuration_impl, get_platform_impl, \
+    get_platform_type_impl, PlatformSpecification
+from idmtools.registry.plugin_specification import get_description_impl
+
+
+SLURM_EXAMPLE_CONFIG = """
+[Slurm]
+job_directory = /data
+# values on ALL or END. 
+# All will email you as the job changes states
+# END with email you when the job is done
+mail_type = 'END'
+mail_user = 'ccollins@idmod.org'
+"""
+
+
+class SlurmPlatformSpecification(PlatformSpecification):
+
+    @get_description_impl
+    def get_description(self) -> str:
+        return "Provides access to the Slurm Platform to IDM Tools"
+
+    @get_platform_impl
+    def get(self, **configuration) -> IPlatform:
+        """
+        Build our slurm platform from the passed in configuration object
+
+        We do our import of platform here to avoid any weirdness
+        Args:
+            configuration:
+
+        Returns:
+
+        """
+        from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+        return SlurmPlatform(**configuration)
+
+    @example_configuration_impl
+    def example_configuration(self):
+        return SLURM_EXAMPLE_CONFIG
+
+    @get_platform_type_impl
+    def get_type(self) -> Type['SlurmPlatform']:  # noqa: F821
+        from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+        return SlurmPlatform
+
+    def get_version(self) -> str:
+        """
+        Returns the version of the plugin
+
+        Returns:
+            Plugin Version
+        """
+        from idmtools_platform_slurm import __version__
+        return __version__
+
+    def get_configuration_aliases(self) -> Dict[str, Dict]:
+        """Provides configuration aliases that exist in SLURM."""
+        config_aliases = dict(
+            SLURM_LOCAL=dict(
+                job_directory=str(Path.home())
+            ),
+            SLURM_CLUSTER=dict(
+                job_directory=str(Path.home())
+            )
+        )
+        return config_aliases

idmtools_platform_slurm/slurm_operations/__init__.py

@@ -0,0 +1,5 @@
+"""
+Here we implement the SlurmPlatform operations.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""