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

idmtools_platform_slurm/utils/status_report/status_report.py

@@ -0,0 +1,242 @@
+"""
+This is a SlurmPlatform simulation status utility.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import os
+import copy
+import json
+from pathlib import Path
+from logging import getLogger
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Dict, Tuple, TYPE_CHECKING
+from idmtools.core import ItemType, EntityStatus
+from idmtools.entities.experiment import Experiment
+from idmtools_platform_file.platform_operations.utils import FILE_MAPS
+
+if TYPE_CHECKING:  # pragma: no cover
+    from idmtools.entities.iplatform import IPlatform
+
+user_logger = getLogger('user')
+
+
+@dataclass(repr=False)
+class StatusViewer:
+    """
+    A class to wrap the functions involved in retrieving simulations status.
+    """
+    platform: 'IPlatform'  # noqa F821
+    scope: Tuple[str, ItemType] = field(default=None)
+
+    _exp: Experiment = field(default=None, init=False, compare=False)
+    _summary: Dict = field(default_factory=dict, init=False, compare=False)
+    _report: Dict = field(default_factory=dict, init=False, compare=False)
+
+    def __post_init__(self):
+        self.initialize()
+
+    def initialize(self) -> None:
+        """
+        Determine the experiment and build dictionary with basic info.
+        Returns:
+            None
+        """
+        if self.scope is not None:
+            item = self.platform.get_item(self.scope[0], self.scope[1])
+            if self.scope[1] == ItemType.SUITE:
+                # Only consider the first experiment
+                self._exp = item.experiments[0]
+            elif self.scope[1] == ItemType.EXPERIMENT:
+                self._exp = item
+            else:
+                raise RuntimeError('Only support Suite/Experiment.')
+        else:
+            try:
+                # take the last suite as the search scope
+                last_suite_dir = max(Path(self.platform.job_directory).glob('*/'), key=os.path.getmtime)
+            except:
+                raise FileNotFoundError("Could not find the last Suite!")
+            try:
+                batch_dir = max(Path(last_suite_dir).glob('*/sbatch.sh'), key=os.path.getmtime)
+            except:
+                raise FileNotFoundError("Could not find the last Experiment!")
+
+            exp_dir = Path(batch_dir).parent
+            exp_id = exp_dir.name
+            self._exp = self.platform.get_item(exp_id, ItemType.EXPERIMENT)
+
+            user_logger.info('------------------------------')
+            user_logger.info(f'last suite dir: {last_suite_dir}')
+            user_logger.info(f'last experiment dir: {exp_dir}')
+            user_logger.info('------------------------------')
+
+        job_id_path = self.platform.get_directory(self._exp).joinpath('job_id.txt')
+        if job_id_path.exists():
+            job_id = open(job_id_path).read().strip()
+        else:
+            job_id = None
+        self._summary = dict(job_id=job_id, suite=self._exp.parent.id, experiment=self._exp.id,
+                             job_directory=self.platform.job_directory)
+
+    def apply_filters(self, status_filter: Tuple[str] = None, job_filter: Tuple[str] = None,
+                      sim_filter: Tuple[str] = None, root: str = 'sim', verbose: bool = True) -> None:
+        """
+        Filter simulations.
+        Args:
+            status_filter: tuple with target status
+            job_filter: tuple with slurm job id
+            sim_filter: tuple with simulation id
+            root: dictionary root key: 'sim' or 'job'
+            verbose: True/False to include simulation directory
+        Returns:
+            None
+        """
+        # Make sure we get the latest status
+        self.platform.refresh_status(self._exp)
+
+        # Filter simulations and format the results
+        _simulations = self._exp.simulations
+        for sim in _simulations:
+            # Apply simulation filter
+            if sim_filter is not None and sim.id not in sim_filter:
+                continue
+
+            sim_dir = self.platform.get_directory(sim)
+            job_status_path = sim_dir.joinpath("job_status.txt")
+            if not job_status_path.exists():
+                continue
+
+            job_id_path = sim_dir.joinpath('job_id.txt')
+            if job_id_path.exists():
+                job_id = open(job_id_path).read().strip()
+            else:
+                job_id = None
+
+            status = open(job_status_path).read().strip()
+            # Apply status filter
+            if status_filter is not None and status not in status_filter:
+                continue
+
+            # Apply slurm job filter
+            if job_filter is not None and job_id not in job_filter:
+                continue
+
+            # Format the results
+            if root == 'job':
+                # job_id as root
+                d = dict(sim=sim.id, status=status)
+                if verbose:
+                    d["WorkDir"] = str(self.platform.get_directory(sim))
+                self._report[job_id] = d
+            elif root == 'sim':
+                # sim_id as root
+                d = dict(job_id=job_id, status=status)
+                if verbose:
+                    d["WorkDir"] = str(self.platform.get_directory(sim))
+                self._report[sim.id] = d
+
+    @staticmethod
+    def output_definition() -> None:
+        """
+        Output the status definition.
+        Returns:
+            None
+        """
+        slurm_map = copy.deepcopy(FILE_MAPS)
+        slurm_map.pop('None', None)
+        user_logger.info('------------------------------')
+        user_logger.info("STATUS DEFINITION")
+        user_logger.info(f"{'0: '.ljust(20)} {slurm_map['0'].name}")
+        user_logger.info(f"{'-1: '.ljust(20)} {slurm_map['-1'].name}")
+        user_logger.info(f"{'100: '.ljust(20)} {slurm_map['100'].name}")
+        user_logger.info('------------------------------')
+
+    def output_summary(self) -> None:
+        """
+        Output slurm job id, suite/experiment id and job directory.
+        Returns:
+            None
+        """
+        if self._summary:
+            user_logger.info(f"{'job id: '.ljust(20)} {self._summary['job_id']}")
+            user_logger.info(f"{'suite: '.ljust(20)} {self._summary['suite']}")
+            user_logger.info(f"{'experiment: '.ljust(20)} {self._summary['experiment']}")
+            user_logger.info(f"{'job directory: '.ljust(20)} {self._summary['job_directory']}")
+
+    def output_status_report(self, status_filter: Tuple[str] = None, job_filter: Tuple[str] = None,
+                             sim_filter: Tuple[str] = None, root: str = 'sim', verbose: bool = True,
+                             display: bool = True, display_count: int = 20) -> None:
+        """
+        Output simulations status with possible override parameters.
+        Args:
+            status_filter: tuple with target status
+            job_filter: tuple with slurm job id
+            sim_filter: tuple with simulation id
+            root: dictionary root key: 'sim' or 'job'
+            verbose: True/False to include simulation directory
+            display: True/False to print the searched results
+            display_count: how many to print
+        Returns:
+            None
+        """
+        if status_filter is None:
+            status_filter = ('0', '-1', '100')
+
+        self.apply_filters(status_filter, job_filter, sim_filter, root, verbose)
+
+        self.output_summary()
+
+        if display:
+            if display_count is None or len(self._report) <= display_count:
+                report_view_dict = self._report
+            else:
+                report_view_dict = dict(list(self._report.items())[0:display_count])
+            user_logger.info(json.dumps(report_view_dict, indent=3))
+
+        self.output_definition()
+
+        if display and len(self._report) > display_count:
+            user_logger.info(f"ONLY DISPLAY {display_count} ITEMS")
+
+        _status_list = [v["status"] for k, v in self._report.items()]
+        _sim_not_run_list = [sim for sim in self._exp.simulations if sim.status == EntityStatus.CREATED]
+        _simulation_count = len(self._exp.simulations)
+
+        # print report
+        user_logger.info(f"{'status filter: '.ljust(20)} {status_filter}")
+        user_logger.info(f"{'job filter: '.ljust(20)} {job_filter}")
+        user_logger.info(f"{'sim filter: '.ljust(20)} {sim_filter}")
+        user_logger.info(f"{'verbose: '.ljust(20)} {verbose}")
+        user_logger.info(f"{'display: '.ljust(20)} {display}")
+        user_logger.info(f"{'Simulation Count: '.ljust(20)} {_simulation_count}")
+        user_logger.info(f"{'Match Count: '.ljust(20)} {len(self._report)} ({dict(Counter(_status_list))})")
+        user_logger.info(f"{'Not Running Count: '.ljust(20)} {len(_sim_not_run_list)}")
+
+        if self._exp.status is None:
+            user_logger.info(f'\nExperiment Status: {None}')
+        else:
+            user_logger.info(f'\nExperiment Status: {self._exp.status.name}')
+
+
+def generate_status_report(platform: 'IPlatform', scope: Tuple[str, ItemType] = None, status_filter: Tuple[str] = None,
+                           job_filter: Tuple[str] = None, sim_filter: Tuple[str] = None, root: str = 'sim',
+                           verbose: bool = True, display: bool = True, display_count: int = 20) -> None:
+    """
+    The entry point of status viewer.
+    Args:
+        platform: idmtools Platform
+        scope: the search base
+        status_filter: tuple with target status
+        job_filter: tuple with slurm job id
+        sim_filter: tuple with simulation id
+        root: dictionary with root key: 'sim' or 'job'
+        verbose: True/False to include simulation directory
+        display: True/False to print the search results
+        display_count: how many to print
+    Returns:
+        None
+    """
+    sv = StatusViewer(scope=scope, platform=platform)
+    sv.output_status_report(status_filter=status_filter, job_filter=job_filter, sim_filter=sim_filter,
+                            root=root, verbose=verbose, display=display, display_count=display_count)

idmtools_platform_slurm/utils/status_report/utils.py

@@ -0,0 +1,108 @@
+"""
+This is a SlurmPlatform utility.
+
+Copyright 2021, Bill & Melinda Gates Foundation. All rights reserved.
+"""
+import os
+from pathlib import Path
+from logging import getLogger
+from typing import Dict, TYPE_CHECKING
+from idmtools.core import ItemType
+
+if TYPE_CHECKING:  # pragma: no cover
+    from idmtools.entities.iplatform import IPlatform
+
+user_logger = getLogger('user')
+
+
+def get_latest_experiment(platform: 'IPlatform') -> Dict:
+    """
+    Find the latest experiment.
+    Args:
+        platform:
+    Returns:
+        Dictionary with experiment info
+    """
+    try:
+        # take the last suite as the search scope
+        last_suite_dir = max(Path(platform.job_directory).glob('*/'), key=os.path.getmtime)
+        batch_dir = max(Path(last_suite_dir).glob('*/sbatch.sh'), key=os.path.getmtime)
+        exp_dir = Path(batch_dir).parent
+        exp_id = exp_dir.name
+        suite_id = exp_dir.parent.name
+
+        job_id_path = exp_dir.joinpath('job_id.txt')
+        if not job_id_path.exists():
+            job_id = None
+        else:
+            job_id = open(job_id_path).read().strip()
+
+        r = dict(job_id=job_id, suite_id=suite_id, experiment_id=exp_id, experiment_directory=str(exp_dir),
+                 job_directory=str(platform.job_directory))
+        return r
+    except:
+        raise FileNotFoundError("Could not find the last Experiment")
+
+
+def check_status(platform: 'IPlatform', exp_id: str = None, display: bool = False) -> None:
+    """
+    List simulations status.
+    Args:
+        platform: Platform
+        exp_id: experiment id
+        display: True/False
+    Returns:
+        None
+    """
+    if exp_id is None:
+        exp_dic = get_latest_experiment(platform)
+        exp_id = exp_dic['experiment_id']
+
+    _exp = platform.get_item(exp_id, ItemType.EXPERIMENT)
+
+    _pending = []
+    _running = []
+    _failed = []
+    _succeeded = []
+    _simulations = _exp.simulations
+    for sim in _simulations:
+        sim_dir = platform.get_directory(sim)
+        job_status_path = sim_dir.joinpath("job_status.txt")
+        if not job_status_path.exists():
+            _pending.append(f"    {sim.id}")
+        else:
+            status = open(job_status_path).read().strip()
+            if status == '0':
+                _succeeded.append(f"    {sim.id}")
+            elif status == '100':
+                _running.append(f"    {sim.id}")
+            elif status == '-1':
+                _failed.append(f"    {sim.id}")
+            else:
+                _running.append(f"    {sim.id}")
+
+    user_logger.info(f'\nExperiment Directory: \n{str(platform.get_directory(_exp))}')
+
+    # Output report
+    user_logger.info(f"\n{'Simulation Count: '.ljust(20)} {len(_simulations)}\n")
+
+    user_logger.info(f'SUCCEEDED ({len(_succeeded)})')
+    if display:
+        user_logger.info('\n'.join(_succeeded))
+
+    user_logger.info(f'FAILED ({len(_failed)})')
+    if display:
+        user_logger.info('\n'.join(_failed))
+
+    user_logger.info(f'RUNNING ({len(_running)})')
+    if display:
+        user_logger.info('\n'.join(_running))
+
+    user_logger.info(f'PENDING ({len(_pending)})')
+    if display:
+        user_logger.info('\n'.join(_pending))
+
+    if _exp.status is None:
+        user_logger.info(f'\nExperiment Status: {None}')
+    else:
+        user_logger.info(f'\nExperiment Status: {_exp.status.name}\n')

idmtools_platform_slurm-0.0.2.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: idmtools_platform_slurm
+Version: 0.0.2
+Summary: Provides ability to run against Slurm
+Author-email: Sharon Chen <schen@idmod.org>, Clinton Collins <ccollins@idmod.org>, Zhaowei Du <zdu@idmod.org>, Clark Kirkman IV <ckirkman@idmod.org>, Benoit Raybaud <braybaud@idmod.org>
+Project-URL: Homepage, https://github.com/InstituteforDiseaseModeling/idmtools
+Keywords: modeling,IDM
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.TXT
+Requires-Dist: idmtools_platform_general<1.0.0,>=0.0.0
+Requires-Dist: dataclasses-json
+Provides-Extra: test
+Requires-Dist: idmtools[test]; extra == "test"
+Requires-Dist: idmtools_models; extra == "test"
+Requires-Dist: idmtools_test; extra == "test"
+Dynamic: license-file
+
+![Staging: idmtools-platform-slurm](https://github.com/InstituteforDiseaseModeling/idmtools/workflows/Staging:%20idmtools-platform-slurm/badge.svg?branch=dev)
+
+# idmtools-platform-slurm
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**
+
+- [Introduction](#introduction)
+- [Setting Up Virtual Environment](#setting-up-virtual-environment)
+- [Development Tips](#development-tips)
+- [Manually run a script as a Slurm job](#manually-run-a-script-as-a-slurm-job)
+- [Use SlurmJob to run a script as a Slurm job](#use-slurmjob-to-run-a-script-as-a-slurm-job)
+- [With SlurmPlatform to run a script as a Slurm job](#with-slurmplatform-to-run-a-script-as-a-slurm-job)
+- [Folder structure:](#folder-structure)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Introduction
+
+**SlurmPlatform** is a platform designed to facilitate the execution of experiments and simulations in slurm cluster. 
+
+## Setting Up Virtual Environment
+
+To set up a virtual environment for **SlurmPlatform**, follow these steps:
+
+1. **Install Python**
+
+   Ensure you have Python 3.8+ installed on your system.
+
+2. **Create Virtual Environment**
+   
+   There are multiple ways to create a virtual environment. Below is an example using `venv`:
+
+    ```bash
+    python -m venv slurm_env
+    ```
+
+3. **Activate Virtual Environment**
+    - On Windows:
+        ```bash
+        slurm_env\Scripts\activate
+        ```
+    - On Linux:
+        ```bash
+        source slurm_env/bin/activate
+        ```
+
+4. **Install SlurmPlatform**
+    ```bash
+    pip install idmtools-platform-slurm --index-url=https://packages.idmod.org/api/pypi/pypi-production/simple
+    ```
+
+5. **Install Dependencies**
+    ```bash
+    pip install -r requirements.txt
+    ```
+6. **Optional(No need step #4 and #5), Install all slurm platform related packages**
+    ```bash
+    pip install idmtools[slurm] --index-url=https://packages.idmod.org/api/pypi/pypi-production/simple
+    ```
+
+## Development Tips
+
+There is a Makefile file available for most common development tasks. Here is a list of commands
+
+```bash
+clean       -   Clean up temproary files
+lint        -   Lint package and tests
+test        -   Run All tests
+coverage    -   Run tests and generate coverage report that is shown in browser
+```
+
+On Windows, you can use `pymake` instead of `make`
+
+
+## Manually run a script as a Slurm job
+
+Preparation
+
+(1).Have target script ready, say my_script.py, suppose you have folder structure like::
+
+```bash
+script_folder
+    my_script.py
+    ......
+```
+
+(2). Created a virtual environment and activated it.
+
+Steps
+
+1. within the target script folder, create a batch file 'sbatch.sh' (without quote) with content:
+
+```bash
+#!/bin/bash
+
+#SBATCH --partition=b1139
+#SBATCH --time=10:00:00
+#SBATCH --account=b1139
+
+#SBATCH --output=stdout.txt
+#SBATCH --error=stderr.txt
+
+# replace with your script file
+python3 my_script.py
+    
+exit $RESULT
+```
+
+Note: the content here is based on Northwestern University QUEST Slurm system. For general case, above content (required #SBATCH parameters) may be a little bit different.
+
+2. run your target script as SLURM job
+   execute the following commands from console (under virtual environment):
+
+   cd path_to_script_folder
+
+   `sbatch sbatch.sh`
+
+Note: any output information from my_script.py is stored in file stdout.txt under the current folder. For example, if my_script.py kicks out another Slurm job, then its Slurm id information can be found in file stdout.txt.
+
+
+## Use SlurmJob to run a script as a Slurm job
+
+The example can be simple as the following:
+
+--script.py--
+
+```python
+
+   from idmtools.core.platform_factory import Platform
+   from idmtools_platform_slurm.utils.slurm_job.slurm_job import SlurmJob
+
+   script = '<user script path>'
+   # script = 'example_path/python_sim_slurm.py'   # example
+   platform = Platform('SLURM_LOCAL', job_directory='<job_directory>')
+   sj = SlurmJob(script_path=script, platform=platform)
+   sj.run()
+```
+
+## With SlurmPlatform to run a script as a Slurm job
+
+We have SlurmJob integrated into SlurmPlatform and any Python script can run as a Slurm job simply doing:
+
+--script.py--
+```python
+
+   from idmtools.entities.command_task import CommandTask
+   from idmtools.entities.experiment import Experiment
+   from idmtools.core.platform_factory import Platform
+   
+   platform = Platform('SLURM_LOCAL', job_directory='<job_directory>')
+   # Define task
+   command = "echo 'Hello, World!'"
+   task = CommandTask(command=command)
+   # Run an experiment
+   experiment = Experiment.from_task(task, name="example")
+   experiment.run(platform=platform)
+```
+
+## Folder structure:
+[See Folder Structure](../idmtools_platform_container/README.md#folder-structure)

idmtools_platform_slurm-0.0.2.dist-info/RECORD

@@ -0,0 +1,43 @@
+dockerized_slurm/Dockerfile,sha256=4RPG_BANNHeFsmaXAaq8yrwKBBf--86tCc1Gdd3dDpg,3735
+dockerized_slurm/README.md,sha256=PN-ux12eNJa8bGqrHJANqNyDaBluqJT7FfDErhKxINA,957
+dockerized_slurm/docker-compose.yml,sha256=Rs0-RxTancLZ7TGFhFVDLpHISm6xq6qPiv4LdPWazJU,1771
+dockerized_slurm/docker-entrypoint.sh,sha256=WbRkpa6mjMtyf_Lq5ZjclrkEl6OwcH7nxBo1hSC9GKI,1667
+dockerized_slurm/id_rsa,sha256=J-PFB9fWCx4AKMM-zFl0wo5WHemuyJTh8G7H9KUm4nU,1675
+dockerized_slurm/id_rsa.pub,sha256=5c2f-UWQGME7exCl4voGguKhCHxfaIka93dpVSUXM8Y,396
+dockerized_slurm/register_cluster.sh,sha256=02_206v7-H_fkMEKqkm5zajhQblCauZlBqpOpnO44fo,508
+dockerized_slurm/slurm.conf,sha256=HeiGJLZCEcGqNQuDGqGevmtEG_Gl_zGIt5arBbnGka0,2043
+dockerized_slurm/slurmdbd.conf,sha256=M9kbzUPr_RwUcGRkvLZlc3kc3CkiD_dRYSq4geQ7DNQ,720
+idmtools_platform_slurm/__init__.py,sha256=TilQFlhJPT6R-Gefmsu4bpY7DKynEDiMV2k-XDoIh4k,371
+idmtools_platform_slurm/plugin_info.py,sha256=gLuEDBEATv3_UoqmgMzZPaOK-kkAEVnQNG2L_S6zAV4,2198
+idmtools_platform_slurm/slurm_platform.py,sha256=Nz8IygyUbg_AhiP6Rae_97p6SLNI2K-2hyzht8ix7x0,9478
+idmtools_platform_slurm/assets/__init__.py,sha256=lD_Pcfh9JEKpbdq8cY-fVv04WAnW4GOSsC7jOM0Cr9Q,5957
+idmtools_platform_slurm/assets/_run.sh.jinja2,sha256=V1GErXW0xEB3FC7mIGysvqd2c6Xx5Fj9yCUjcXAgmmE,1218
+idmtools_platform_slurm/assets/batch.sh.jinja2,sha256=2ifVKLgzZBAlwtTOSdYFP4yaJyWxonIchu1pN-23rI4,1809
+idmtools_platform_slurm/assets/run_simulation.sh,sha256=6XA9TerH2DwHrffu230XB5s5x_MitPG49ezWf6rz0z8,829
+idmtools_platform_slurm/assets/sbatch.sh.jinja2,sha256=utDXl3tUwsH87vBhHCQkPAEXWzMCRNhpYL5AoVPYmHw,2182
+idmtools_platform_slurm/cli/__init__.py,sha256=JK3TNc2XaF73-1EKgfLQZse6E9fudu6wVb-MedflQHA,109
+idmtools_platform_slurm/cli/slurm.py,sha256=Crdni0Y1n60jD5bFnIEEPslIKZ4GCCCiAO25ytGK8IU,6211
+idmtools_platform_slurm/platform_operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idmtools_platform_slurm/platform_operations/asset_collection_operations.py,sha256=ZnjBVzWitGJgLuuehS_y9uw-I9CKBrsa6YK_Z_yhdPo,832
+idmtools_platform_slurm/platform_operations/experiment_operations.py,sha256=iPc9Op2gchQuXQfUQVjsnFHlSQ0Bh0yJmNcbyyCmY3I,4183
+idmtools_platform_slurm/platform_operations/json_metadata_operations.py,sha256=5-doVLV6_llRlw9CQXi3NeN3DSCYp6QKkD1kaqA9LaQ,537
+idmtools_platform_slurm/platform_operations/simulation_operations.py,sha256=o_EnhP2oqDOxcZkIwnhJVV4i0WBSH1kXry6stEQ7lYU,1675
+idmtools_platform_slurm/platform_operations/suite_operations.py,sha256=lFziJEa7OFTWuGXfaA2lbxawOMd-220QXLmI6XoHFKs,1209
+idmtools_platform_slurm/platform_operations/utils.py,sha256=Zl40ZHJJQwFmiSOxLWj7kTvlGxYrG03sOZl9AHtPFBA,1064
+idmtools_platform_slurm/slurm_operations/__init__.py,sha256=jYdcawEe9ov5ZHBYitdwPaWNp7nb70YuIH5Ev0H3E1c,127
+idmtools_platform_slurm/slurm_operations/slurm_operations.py,sha256=LyZZUVSOcfWTBKdzNSv4-xLbUmEYm2YeIXG7_fSX_eM,2097
+idmtools_platform_slurm/utils/__init__.py,sha256=QeEbFLLYcsehsfXfPbPqay_d96tLkPpql_Ahz9q226g,104
+idmtools_platform_slurm/utils/slurm_job/__init__.py,sha256=tjyUCjlbBuWyMipKRgOXwu5nANjAxMov5FUllJSSup8,2491
+idmtools_platform_slurm/utils/slurm_job/script_sbatch.sh.jinja2,sha256=P3vQeZFLJ9AAqpjLOfga2Cca_duTa6Ys0YLwh80Bcok,2231
+idmtools_platform_slurm/utils/slurm_job/slurm_job.py,sha256=_MdIzidWMSIRDs5_A0ELiE1K2PuOb7bAwl5adgeVUZA,8406
+idmtools_platform_slurm/utils/status_report/__init__.py,sha256=ILUUhLx3p0l726YI1qtmhSBnV92DOFs9KHKYntOkGNI,114
+idmtools_platform_slurm/utils/status_report/status_report.py,sha256=YY8iC0Mgh79TORpaCWiyJSXsDyPmXTzno67kuXa5KWU,10249
+idmtools_platform_slurm/utils/status_report/utils.py,sha256=0QAtE-_CD9Y6IpsgdhT379qN5sbR7UkFL6az8RwZiXs,3443
+idmtools_platform_slurm-0.0.2.dist-info/licenses/LICENSE.TXT,sha256=l9S8Ydr_LcejxKoqK8191ZAOsmVX-nJLSPoLKZDUgcg,197
+tests/input/hello.sh,sha256=S_6eEZfsGz3i4Ren-LqcHd090IV8yVzxI9OlgrU6SiQ,30
+tests/input/script.py,sha256=ivZ0LxyDpRAuLn-aGNZ8_Blj-NNzhuvvWGNAwRO934Q,1691
+idmtools_platform_slurm-0.0.2.dist-info/METADATA,sha256=do-If0miZVqyD5X9ZyGw7BabMJQFIExA0BIzVPY5gLU,5846
+idmtools_platform_slurm-0.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+idmtools_platform_slurm-0.0.2.dist-info/entry_points.txt,sha256=TBIO1R0BqtWLR6IfVxVRA9FX5qWQpdksS_Y0w7s9U_k,185
+idmtools_platform_slurm-0.0.2.dist-info/top_level.txt,sha256=1edevWgVuF15I7sxrX2ExQ5A8exjnqbKpwYfqRWznLA,47
+idmtools_platform_slurm-0.0.2.dist-info/RECORD,,

idmtools_platform_slurm-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[idmtools_cli.cli_plugins]
+slurm = idmtools_platform_slurm.cli.slurm:slurm
+
+[idmtools_platform]
+idmtools_platform_slurm = idmtools_platform_slurm.plugin_info:SlurmPlatformSpecification

idmtools_platform_slurm-0.0.2.dist-info/licenses/LICENSE.TXT

@@ -0,0 +1,3 @@
+idmtools is licensed under the Creative Commons Attribution-Noncommercial-ShareAlike 4.0 License.
+
+To view a copy of this license, visit https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode

{idmtools_platform_slurm-0.0.0.dev0.dist-info → idmtools_platform_slurm-0.0.2.dist-info}/top_level.txt

@@ -1 +1,3 @@
+dockerized_slurm
 idmtools_platform_slurm
+tests

tests/input/hello.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Hello World"

tests/input/script.py

@@ -0,0 +1,49 @@
+
+import os
+import sys
+from functools import partial
+from typing import Any, Dict
+
+from idmtools.builders import SimulationBuilder
+from idmtools.core.platform_factory import Platform
+from idmtools.entities import Suite
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.simulation import Simulation
+from idmtools.entities.templated_simulation import TemplatedSimulations
+from idmtools_models.python.json_python_task import JSONConfiguredPythonTask
+
+from idmtools_test import COMMON_INPUT_PATH
+
+
+#print(sys.argv[1:])
+parms = [int(x) for x in sys.argv[1:]]
+job_directory = os.path.join(os.path.expanduser('~'), "DEST")
+platform = Platform('SLURM_LOCAL', job_directory=job_directory)
+
+task = JSONConfiguredPythonTask(script_path=os.path.join(COMMON_INPUT_PATH, "python", "model3.py"),
+                                envelope="parameters", parameters=(dict(c=0)))
+task.python_path = "python3"
+ts = TemplatedSimulations(base_task=task)
+builder = SimulationBuilder()
+
+
+def param_update(simulation: Simulation, param: str, value: Any) -> Dict[str, Any]:
+    return simulation.task.set_parameter(param, value)
+
+# Let's sweep the parameter 'a'
+builder.add_sweep_definition(partial(param_update, param="a"), [parms[0]])
+
+# Let's sweep the parameter 'b'
+builder.add_sweep_definition(partial(param_update, param="b"), parms[1:])
+ts.add_builder(builder)
+
+experiment = Experiment.from_template(ts, name="slurmjob example")
+experiment.assets.add_directory(assets_directory=os.path.join(COMMON_INPUT_PATH, "python", "Assets"))
+
+# Create suite
+suite = Suite(name='Idm Suite')
+suite.add_experiment(experiment)
+
+suite.run(platform=platform, wait_until_done=True, max_running_jobs=10)
+
+