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

idmtools_platform_slurm/slurm_operations/slurm_operations.py

@@ -0,0 +1,58 @@
+"""
+Here we implement the Slurm Operations.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+import subprocess
+from dataclasses import dataclass, field
+from logging import getLogger
+from typing import Union, List, Any, Type
+
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.simulation import Simulation
+from idmtools_platform_file.file_operations.file_operations import FileOperations
+from idmtools_platform_slurm.assets import generate_batch, generate_script, generate_simulation_script
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class SlurmOperations(FileOperations):
+
+    platform: 'SlurmPlatform'  # noqa: F821
+    platform_type: Type = field(default=None)
+
+    def create_batch_file(self, item: Union[Experiment, Simulation], max_running_jobs: int = None, retries: int = None,
+                          array_batch_size: int = None, dependency: bool = True, **kwargs) -> None:
+        """
+        Create batch file.
+        Args:
+            item: the item to build batch file for
+            kwargs: keyword arguments used to expand functionality.
+        Returns:
+            None
+        """
+        if isinstance(item, Experiment):
+            generate_batch(self.platform, item, max_running_jobs, array_batch_size, dependency)
+            generate_script(self.platform, item, max_running_jobs)
+        elif isinstance(item, Simulation):
+            generate_simulation_script(self.platform, item, retries)
+        else:
+            raise NotImplementedError(f"{item.__class__.__name__} is not supported for batch creation.")
+
+    @staticmethod
+    def cancel_job(job_ids: Union[str, List[str]]) -> Any:
+        """
+        Cancel Slurm job for given job ids.
+        Args:
+            job_ids: slurm jobs id
+        Returns:
+            Any
+        """
+        if isinstance(job_ids, str):
+            job_ids = [job_ids]
+        logger.debug(f"Submit slurm cancel job: {job_ids}")
+        result = subprocess.run(['scancel', *job_ids], stdout=subprocess.PIPE)
+        stdout = "Success" if result.returncode == 0 else 'Error'
+        return stdout

idmtools_platform_slurm/slurm_platform.py

@@ -0,0 +1,207 @@
+"""
+Here we implement the SlurmPlatform object.
+
+Copyright 2025, Gates Foundation. All rights reserved.
+"""
+import subprocess
+from typing import Optional, Any, Dict, List, Union, Literal
+from dataclasses import dataclass, field, fields
+from logging import getLogger
+from idmtools.core import ItemType
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.simulation import Simulation
+from idmtools_platform_file.file_platform import FilePlatform
+from idmtools_platform_slurm.platform_operations.json_metadata_operations import SlurmJSONMetadataOperations
+from idmtools_platform_slurm.platform_operations.asset_collection_operations import \
+    SlurmPlatformAssetCollectionOperations
+from idmtools_platform_slurm.platform_operations.experiment_operations import SlurmPlatformExperimentOperations
+from idmtools_platform_slurm.platform_operations.simulation_operations import SlurmPlatformSimulationOperations
+from idmtools_platform_slurm.platform_operations.suite_operations import SlurmPlatformSuiteOperations
+from idmtools_platform_slurm.platform_operations.utils import get_max_array_size
+from idmtools_platform_slurm.slurm_operations.slurm_operations import SlurmOperations
+
+from idmtools_platform_slurm.utils.slurm_job import run_script_on_slurm, slurm_installed
+
+logger = getLogger(__name__)
+
+op_defaults = dict(default=None, compare=False, metadata={"pickle_ignore": True})
+CONFIG_PARAMETERS = ['ntasks', 'partition', 'nodes', 'mail_type', 'mail_user', 'ntasks_per_core', 'cpus_per_task',
+                     'mem_per_cpu', 'time', 'constraint', 'account', 'mem', 'exclusive', 'requeue', 'sbatch_custom',
+                     'max_running_jobs', 'array_batch_size', 'mpi_type']
+
+
+@dataclass(repr=False)
+class SlurmPlatform(FilePlatform):
+    # region: Resources request
+
+    # choose e-mail type
+    mail_type: Optional[str] = field(default=None, metadata=dict(sbatch=True, help="e-mail type"))
+
+    # send e=mail notification
+    # TODO Add Validations here from https://slurm.schedmd.com/sbatch.html#OPT_mail-type
+    mail_user: Optional[str] = field(default=None, metadata=dict(sbatch=True, help="e-mail address"))
+
+    # How many nodes to be used
+    nodes: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Number of nodes"))
+
+    # Num of tasks
+    ntasks: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Number of tasks"))
+
+    # CPU # per task
+    cpus_per_task: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Number of CPUs per task"))
+
+    # Task # per core
+    ntasks_per_core: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Number of tasks per core"))
+
+    # Maximum of running jobs(Per experiment)
+    max_running_jobs: Optional[int] = field(default=100, metadata=dict(sbatch=True, help="Maximum of running jobs"))
+
+    # Memory per core: MB of memory
+    mem: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Memory per core"))
+
+    # Memory per core: MB of memory
+    mem_per_cpu: Optional[int] = field(default=None, metadata=dict(sbatch=True, help="Memory per CPU"))
+
+    # Which partition to use
+    partition: Optional[str] = field(default=None, metadata=dict(sbatch=True, help="Partition"))
+
+    # Specify compute node
+    constraint: Optional[str] = field(default=None, metadata=dict(sbatch=True, help="Constraint"))
+
+    # Limit time on this job hrs:min:sec
+    time: str = field(default=None, metadata=dict(sbatch=True, help="Limit time on this job"))
+
+    # if set to something, jobs will run with the specified account in slurm
+    account: str = field(default=None, metadata=dict(sbatch=True, help="Account"))
+
+    # Allocated nodes can not be shared with other jobs/users
+    exclusive: bool = field(default=False, metadata=dict(sbatch=True, help="Exclusive"))
+
+    # Specifies that the batch job should be eligible for requeuing
+    requeue: bool = field(default=True, metadata=dict(sbatch=True, help="Requeue"))
+
+    # Default retries for jobs
+    retries: int = field(default=1, metadata=dict(sbatch=False, help="Default retries for jobs"))
+
+    # Pass custom commands to sbatch generation script
+    sbatch_custom: Optional[str] = field(default=None, metadata=dict(sbatch=True, help="Custom sbatch commands"))
+
+    # modules to be load
+    modules: list = field(default_factory=list, metadata=dict(sbatch=True, help="Modules to be loaded"))
+
+    # Specifies default setting of whether slurm should fail if item directory already exists
+    dir_exist_ok: bool = field(default=False, repr=False, compare=False, metadata=dict(help="Directory exist ok"))
+
+    # Set array max size for Slurm job
+    array_batch_size: int = field(default=None, metadata=dict(sbatch=False, help="Array batch size"))
+
+    # determine if run script as Slurm job
+    run_on_slurm: bool = field(default=False, repr=False, compare=False, metadata=dict(help="Run script as Slurm job"))
+
+    # mpi type: default to pmi2 for older versions of MPICH or OpenMPI or an MPI library that explicitly requires PMI2
+    mpi_type: Optional[Literal['pmi2', 'pmix', 'mpirun']] = field(default="pmi2", metadata=dict(sbatch=True,
+                                                                                                help="MPI types ('pmi2', 'pmix' for slurm MPI, 'mpirun' for independently MPI)"))
+
+    # endregion
+
+    _suites: SlurmPlatformSuiteOperations = field(**op_defaults, repr=False, init=False)
+    _experiments: SlurmPlatformExperimentOperations = field(**op_defaults, repr=False, init=False)
+    _simulations: SlurmPlatformSimulationOperations = field(**op_defaults, repr=False, init=False)
+    _assets: SlurmPlatformAssetCollectionOperations = field(**op_defaults, repr=False, init=False)
+    _metas: SlurmJSONMetadataOperations = field(**op_defaults, repr=False, init=False)
+    _op_client: SlurmOperations = field(**op_defaults, repr=False, init=False)
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.__init_interfaces()
+
+        # check max_array_size from slurm configuration
+        self._max_array_size = None
+        if slurm_installed():
+            self._max_array_size = get_max_array_size()
+
+        if self.mpi_type.lower() not in {'pmi2', 'pmix', 'mpirun'}:
+            raise ValueError(f"Invalid mpi_type '{self.mpi_type}'. Allowed values are 'pmi2', 'pmix', or 'mpirun'.")
+
+        # check if run script as a slurm job
+        r = run_script_on_slurm(self, run_on_slurm=self.run_on_slurm)
+        if r:
+            exit(0)  # finish the current workflow
+
+    def __init_interfaces(self):
+        self._op_client = SlurmOperations(platform=self)
+        self._suites = SlurmPlatformSuiteOperations(platform=self)
+        self._experiments = SlurmPlatformExperimentOperations(platform=self)
+        self._simulations = SlurmPlatformSimulationOperations(platform=self)
+        self._assets = SlurmPlatformAssetCollectionOperations(platform=self)
+        self._metas = SlurmJSONMetadataOperations(platform=self)
+
+    @property
+    def slurm_fields(self):
+        """
+        Get list of fields that have metadata sbatch.
+        Returns:
+            Set of fields that have sbatch metadata
+        """
+        return set(f.name for f in fields(self) if "sbatch" in f.metadata and f.metadata["sbatch"])
+
+    def get_slurm_configs(self, **kwargs) -> Dict[str, Any]:
+        """
+        Identify the Slurm config parameters from the fields.
+        Args:
+            kwargs: additional parameters
+        Returns:
+            slurm config dict
+        """
+        config_dict = {k: getattr(self, k) for k in self.slurm_fields}
+        config_dict.update(kwargs)
+        return config_dict
+
+    def create_batch_file(self, item: Union[Experiment, Simulation], **kwargs) -> None:
+        """
+        Create batch file.
+        Args:
+            item: the item to build batch file for
+            kwargs: keyword arguments used to expand functionality.
+        Returns:
+            None
+        """
+        self._op_client.create_batch_file(item, **kwargs)
+
+    def get_job_id(self, item_id: str, item_type: ItemType) -> List:
+        """
+        Retrieve the job id for item that had been run.
+        Args:
+            item_id: id of experiment/simulation
+            item_type: ItemType (Experiment or Simulation)
+        Returns:
+            List of slurm job ids
+        """
+        if item_type not in (ItemType.EXPERIMENT, ItemType.SIMULATION):
+            raise RuntimeError(f"Not support item type: {item_type}")
+
+        item_dir = self.get_directory_by_id(item_id, item_type)
+        job_id_file = item_dir.joinpath('job_id.txt')
+        if not job_id_file.exists():
+            logger.debug(f"{job_id_file} not found.")
+            return None
+
+        job_id = open(job_id_file).read().strip()
+        return job_id.split('\n')
+
+    def submit_job(self, item: Union[Experiment, Simulation], **kwargs) -> None:
+        """
+        Submit a Slurm job.
+        Args:
+            item: idmtools Experiment or Simulation
+            kwargs: keyword arguments used to expand functionality
+        Returns:
+            None
+        """
+        if isinstance(item, Experiment):
+            working_directory = self.get_directory(item)
+            subprocess.run(['bash', 'batch.sh'], stdout=subprocess.PIPE, cwd=str(working_directory))
+        elif isinstance(item, Simulation):
+            pass
+        else:
+            raise NotImplementedError(f"Submit job is not implemented on SlurmPlatform.")

idmtools_platform_slurm/utils/__init__.py

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

idmtools_platform_slurm/utils/slurm_job/__init__.py

@@ -0,0 +1,90 @@
+"""
+idmtools SlurmPlatform SlurmJob utils.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import os
+import sys
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+if TYPE_CHECKING:  # pragma: no cover
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+INDICATOR_VARIABLE = 'RUN_ON_SLURM'
+
+
+def create_slurm_indicator() -> NoReturn:
+    """
+    Add environment variable.
+    Returns:
+        None
+    """
+    os.environ[INDICATOR_VARIABLE] = '1'
+
+
+def remove_slurm_indicator() -> NoReturn:
+    """
+    Remove the environment variable.
+    Returns:
+        None
+    """
+    os.environ.pop(INDICATOR_VARIABLE, None)
+
+
+def check_slurm_indicator() -> bool:
+    """
+    Check if the environment set to '1'.
+    Returns:
+        True/False
+    """
+    return os.environ.get(INDICATOR_VARIABLE, '0') == '1'
+
+
+def slurm_installed() -> bool:
+    """
+    Check if Slurm system is installed or available.
+    Returns:
+        True/False
+    """
+    try:
+        subprocess.check_output(["sinfo", "-V"])
+        return True
+    except:
+        return False
+
+
+def run_script_on_slurm(platform: 'SlurmPlatform', run_on_slurm: bool = False,
+                        cleanup: bool = True) -> bool:
+    """
+    This is a utility tool which wraps the SlurmJob creation and run.
+    Args:
+        platform: idmtools Platform
+        run_on_slurm: True/False
+        cleanup: True/False to delete the generated slurm job related files
+    Returns:
+        True/False
+    """
+    from idmtools_platform_slurm.utils.slurm_job.slurm_job import SlurmJob
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+    # Double make sure it is Slurm Platform
+    if not isinstance(platform, SlurmPlatform):
+        return False
+
+    if run_on_slurm and not check_slurm_indicator():
+        # Locate the script
+        # Wrong path due to emod_malaria bug:
+        # script = os.path.abspath(sys.argv[0])
+        # Workaround: manually build full path
+        script = Path(sys.path[0]).joinpath(Path(sys.argv[0]).name)
+        # Collect script input parameters
+        script_params = sys.argv[1:]
+        # Run script as Slurm job
+        sj = SlurmJob(script_path=script, platform=platform, script_params=script_params, cleanup=cleanup)
+        # Kick off Slurm job
+        sj.run()
+        return True
+    else:
+        return False

idmtools_platform_slurm/utils/slurm_job/script_sbatch.sh.jinja2

@@ -0,0 +1,78 @@
+#!/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 %}
+
+# define the handler function
+term_handler()
+{
+# do whatever cleanup you want here
+echo "-1" > job_status.txt
+exit -1
+}
+
+# associate the function "term_handler" with the TERM signal
+trap 'term_handler' TERM
+
+echo $SLURM_JOB_ID > job_id.txt
+
+echo "100" > job_status.txt
+{{ command }}
+RESULT=$?
+if [ $RESULT -eq 0 ]; then
+echo "0" > job_status.txt
+exit $RESULT
+fi
+echo "-1" > job_status.txt
+exit $RESULT

idmtools_platform_slurm/utils/slurm_job/slurm_job.py

@@ -0,0 +1,214 @@
+"""
+This is a SlurmPlatform utility.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import os
+import subprocess
+import time
+from os import PathLike
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import NoReturn, Union, List, TYPE_CHECKING
+from idmtools.core import NoPlatformException
+from jinja2 import Template
+from logging import getLogger
+from idmtools_platform_slurm.utils.slurm_job import create_slurm_indicator, slurm_installed
+from typing import Tuple
+
+
+user_logger = getLogger('user')
+
+if TYPE_CHECKING:
+    from idmtools_platform_slurm.slurm_platform import SlurmPlatform
+
+DEFAULT_TEMPLATE_FILE = "script_sbatch.sh.jinja2"
+MSG = """Note: any output information from your script is stored in file stdout.txt under the script folder. For example, if you are running a script under current directory which kicks out another Slurm job, then the second Slurm job id is stored in stdout.txt under the current directory."""
+
+TEMP_FILES = ['sbatch.sh', 'job_id.txt', 'job_status.txt', 'stdout.txt', 'stderr.txt']
+
+
+def generate_script(platform: 'SlurmPlatform', command: str,
+                    template: Union[Path, str] = DEFAULT_TEMPLATE_FILE, batch_dir: str = None, **kwargs) -> None:
+    """
+    Generate batch file sbatch.sh
+    Args:
+        platform: Slurm Platform
+        command: execution command
+        template: template to be used to build batch file
+        kwargs: keyword arguments used to expand functionality
+    Returns:
+        None
+    """
+    from idmtools_platform_slurm.slurm_platform import CONFIG_PARAMETERS
+    template_vars = dict(
+        platform=platform,
+        command=command
+    )
+    # Populate from our platform config vars
+    for p in CONFIG_PARAMETERS:
+        if getattr(platform, p) is not None:
+            template_vars[p] = getattr(platform, p)
+
+    template_vars.update(kwargs)
+
+    if platform.modules:
+        template_vars['modules'] = platform.modules
+
+    with open(Path(__file__).parent.joinpath(template)) as tin:
+        t = Template(tin.read())
+
+    # Write our file
+    if batch_dir is None:
+        output_target = Path.cwd().joinpath("sbatch.sh")
+    else:
+        output_target = Path(batch_dir).joinpath("sbatch.sh")
+
+    with open(output_target, "w") as tout:
+        tout.write(t.render(template_vars))
+
+    # Make executable
+    platform.update_script_mode(output_target)
+
+
+def check_file_and_job_id(file_path, timeout: int = 3600, interval: int = 10) -> Tuple[bool, str]:
+    """
+    Wait for a file to be created and check if slurm job id exists in the file.
+
+    Args:
+        file_path (str): Path to the file to check.
+        timeout (int): Maximum time (in seconds) to wait for the file and line.
+        interval (int): Time interval (in seconds) between checks.
+
+    Returns:
+        Tuple[bool, str]: A tuple containing:
+            - bool: True if the file exists and contains a valid job ID, False otherwise.
+            - str: The job ID if found, otherwise an empty string.
+    """
+    start_time = time.time()
+
+    while time.time() - start_time < timeout:
+        if os.path.exists(file_path):
+            user_logger.info(f"File {file_path} found.")
+            with open(file_path, 'r') as file:
+                for line in file:
+                    if 'Slurm Job Ids (' in line:
+                        slurm_job_id = file.readline().strip()
+                        if slurm_job_id.isdigit():
+                            return True, slurm_job_id
+            user_logger.warning(f"Not found slurm job id in {file_path}.")
+        else:
+            user_logger.info(f"File {file_path} not found yet. Waiting...")
+
+        time.sleep(interval)
+
+    user_logger.error(f"Timeout reached. File {file_path} or slurm job id not found.")
+    return False, None
+
+
+
+@dataclass(repr=False)
+class SlurmJob:
+    script_path: PathLike = field(init=True)
+    platform: 'SlurmPlatform' = field(default=None, init=True)
+    executable: str = field(default='python3', init=True)
+    script_params: List[str] = field(default=None, init=True)
+    cleanup: bool = field(default=True, init=True)
+
+    def __post_init__(self):
+        if self.script_path is None:
+            raise RuntimeError("script_path is missing!")
+        # load platform from context or from passed in value
+        self.platform = self.__check_for_platform_from_context(self.platform)
+        self.working_directory = Path(self.script_path).parent
+        self.script_params = self.script_params if self.script_params is not None and len(
+            self.script_params) > 0 else None
+        self.slurm_job_id = None
+
+    def initialization(self):
+        # make str list so that we may join them together
+        if self.script_params is not None:
+            self.script_params = [str(i) for i in self.script_params]
+
+        if self.script_params is not None:
+            command = f"{self.executable} {Path(self.script_path).name} {' '.join(self.script_params)}"
+        else:
+            command = f"{self.executable} {Path(self.script_path).name}"
+
+        generate_script(self.platform, command, batch_dir=self.working_directory)
+
+
+    def run(self, dry_run: bool = False, **kwargs) -> NoReturn:
+        if self.cleanup:
+            self.clean(self.working_directory)
+
+        self.initialization()
+
+        if not dry_run:
+            if not slurm_installed():
+                user_logger.warning('Slurm is not installed/available!')
+                exit(-1)
+
+            user_logger.info('Script is running as a slurm job!\n')
+            create_slurm_indicator()
+            result = subprocess.run(['sbatch', '--parsable', 'sbatch.sh'], stdout=subprocess.PIPE,
+                            cwd=str(self.working_directory))
+            self.slurm_job_id = result.stdout.decode('utf-8').strip().split(';')[0]
+
+            user_logger.info(f"{'job_id: '.ljust(20)} {self.slurm_job_id}")
+            user_logger.info(f"{'job_directory: '.ljust(20)} {self.platform.job_directory}\n")
+
+            # Check if stdout.txt is created and job id exists in there
+            stdout_file = os.path.join(self.working_directory, 'stdout.txt')
+            is_exists, slurm_job_id = check_file_and_job_id(stdout_file)
+            if is_exists and slurm_job_id is not None:
+                # print stdout.txt on console
+                with open(stdout_file, "r") as f:
+                    read_data = f.read()
+                    user_logger.info(read_data)
+                user_logger.info("To check job status, run command:")
+                user_logger.info(f"scontrol show job {slurm_job_id}")
+                user_logger.info(f"sacct -j {slurm_job_id} --format=JobID,State,Start,End")
+            else:
+                user_logger.warning("Check status.txt for job details.")
+                user_logger.warning(MSG)
+        else:
+            user_logger.warning('Script is running with dry_run = True')
+
+    def __check_for_platform_from_context(self, platform) -> 'IPlatform':  # noqa: F821
+        """
+        Try to determine platform of current object from self or current platform.
+
+        Args:
+            platform: Passed in platform object
+
+        Raises:
+            NoPlatformException: when no platform is on current context
+        Returns:
+            Platform object
+        """
+        if self.platform is None:
+            # check context for current platform
+            if platform is None:
+                from idmtools.core.context import CURRENT_PLATFORM
+                if CURRENT_PLATFORM is None:
+                    raise NoPlatformException("No Platform defined on object, in current context, or passed to run")
+                platform = CURRENT_PLATFORM
+            self.platform = platform
+        return self.platform
+
+    def clean(self, cwd: str = os.getcwd()):
+        """
+        Delete generated slurm job related files.
+        Args:
+            cwd: the directory containing the files
+        Returns:
+            None
+        """
+        for file_path in TEMP_FILES:
+            f = os.path.join(cwd, file_path)
+            if os.path.exists(f):
+                try:
+                    os.remove(f)
+                except:
+                    pass

idmtools_platform_slurm/utils/status_report/__init__.py

@@ -0,0 +1,5 @@
+"""
+idmtools SlurmPlatform utils.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""