idmtools-test 0.0.0.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

idmtools_test/inputs/python/ye_seir_model/Assets/requirements.txt

@@ -0,0 +1,4 @@
+pandas==0.24.1
+dtk_generic_intrahost==0.1.5
+dtk_nodedemog==0.1.5
+dtk_vaccine_intervention==0.0.5

idmtools_test/inputs/python/ye_seir_model/Assets/templates/config.json

@@ -0,0 +1,68 @@
+{
+    "Age_Initialization_Distribution_Type": "DISTRIBUTION_SIMPLE",
+    "Base_Individual_Sample_Rate": 1,
+    "Base_Infectivity_Distribution": "CONSTANT_DISTRIBUTION",
+    "Base_Year": 2015,
+    "Birth_Rate_Dependence": "FIXED_BIRTH_RATE",
+    "Birth_Rate_Time_Dependence": "NONE",
+    "Config_Name": "Generic_BaseInfectivityDistribution-NOT_INITIALIZED",
+    "Custom_Coordinator_Events": [],
+    "Custom_Individual_Events": [],
+    "Custom_Node_Events": [],
+    "Custom_Reports_Filename": "",
+    "Death_Rate_Dependence": "NOT_INITIALIZED",
+    "Demographics_Filenames": [
+        "demographics.json"
+    ],
+    "Enable_Aging": 1,
+    "Enable_Birth": 1,
+    "Enable_Demographics_Birth": 0,
+    "Enable_Demographics_Builtin": 0,
+    "Enable_Demographics_Gender": 0,
+    "Enable_Demographics_Other": 0,
+    "Enable_Demographics_Risk": 0,
+    "Enable_Disease_Mortality": 0,
+    "Enable_Heterogeneous_Intranode_Transmission": 0,
+    "Enable_Immunity": 1,
+    "Enable_Immunity_Initialization_Distribution": 0,
+    "Enable_Infectivity_Reservoir": 0,
+    "Enable_Infectivity_Scaling": 0,
+    "Enable_Initial_Prevalence": 0,
+    "Enable_Initial_Susceptibility_Distribution": 1,
+    "Enable_Interventions": 0,
+    "Enable_Maternal_Infection_Transmission": 0,
+    "Enable_Maternal_Transmission": 0,
+    "Enable_Natural_Mortality": 1,
+    "Enable_Susceptibility_Scaling": 0,
+    "Enable_Vital_Dynamics": 1,
+    "Incubation_Period_Constant": 0,
+    "Incubation_Period_Distribution": "CONSTANT_DISTRIBUTION",
+    "Individual_Sampling_Type": "FIXED_SAMPLING",
+    "Infectious_Period_Distribution": "CONSTANT_DISTRIBUTION",
+    "Listed_Events": [],
+    "Migration_Model": "NO_MIGRATION",
+    "Node_Grid_Size": 0.005,
+    "Number_Basestrains": 1,
+    "Number_Substrains": 1,
+    "Num_Cores": 1,
+    "Population_Scale_Type": "FIXED_SCALING",
+    "Post_Infection_Acquisition_Multiplier" : 0,
+    "Post_Infection_Transmission_Multiplier": 0,
+    "Post_Infection_Mortality_Multiplier": 0,
+    "Run_Number": 1,
+    "Sample_Rate_0_18mo": 1,
+    "Sample_Rate_10_14": 1,
+    "Sample_Rate_15_19": 1,
+    "Sample_Rate_18mo_4yr": 1,
+    "Sample_Rate_20_Plus": 1,
+    "Sample_Rate_5_9": 1,
+    "Sample_Rate_Birth": 1,
+    "Simulation_Duration": 2,
+    "Simulation_Timestep": 1,
+    "Simulation_Type": "GENERIC_SIM",
+    "Start_Time": 0,
+    "Susceptibility_Initialization_Distribution_Type": "DISTRIBUTION_OFF",
+    "x_Base_Population": 1,
+    "x_Birth": 10,
+    "x_Other_Mortality": 1
+}

idmtools_test/inputs/python/ye_seir_model/Assets/templates/demographics_template.json

@@ -0,0 +1,44 @@
+{
+    "Metadata": {
+        "DateCreated": "Sun Sep 25 23:19:55 2011", 
+        "Tool": "convertdemog.py", 
+        "Author": "jsteinkraus", 
+        "IdReference": "Gridded world grump2.5arcmin", 
+        "NodeCount": 1,
+		"Resolution": 150
+    }, 
+    "Defaults": {
+    },
+    "Nodes": [
+        {
+            "NodeID": 1, 
+            "NodeAttributes": {
+                "Latitude": 1, 
+                "Longitude": 1, 
+                "Altitude": 0, 
+                "Airport": 0, 
+                "Region": 1, 
+                "Seaport": 0, 
+                "InitialPopulation": 10000, 
+                "BirthRate": 0.0548
+            }, 
+            "IndividualAttributes": {
+                "AgeDistributionFlag": 3, 
+                "AgeDistribution1": 0.000118, 
+                "AgeDistribution2": 0, 
+                "PrevalenceDistributionFlag": 0, 
+                "PrevalenceDistribution1": 0.0, 
+                "PrevalenceDistribution2": 0.0, 
+                "SusceptibilityDistributionFlag": 0, 
+                "SusceptibilityDistribution1": 1, 
+                "SusceptibilityDistribution2": 0, 
+                "RiskDistributionFlag": 0, 
+                "RiskDistribution1": 1, 
+                "RiskDistribution2": 0, 
+                "MigrationHeterogeneityDistributionFlag": 0, 
+                "MigrationHeterogeneityDistribution1": 1, 
+                "MigrationHeterogeneityDistribution2": 0
+            }
+        }
+    ]
+}

idmtools_test/inputs/python_experiments/model.py

@@ -0,0 +1,10 @@
+import json
+import time
+
+if __name__ == "__main__":
+    with open("config.json", 'r') as fp:
+        param = json.load(fp)["Run_Number"]
+        if param == 0 or param == 2 or param == 4:
+            raise Exception("Exception!")
+    time.sleep(3)
+    print("Done")

idmtools_test/inputs/r/model1.R

@@ -0,0 +1 @@
+print("Hello World!")

idmtools_test/inputs/r/ncov_analysis/individual_dynamics_estimates/estimate_incubation_period.R

@@ -0,0 +1,89 @@
+# estimate incubation period
+
+# library(tidyverse, lib.loc="./Assets/ncov_analysis/individual_dynamics_estimates/library")
+# library(survival, lib.loc="./Assets/ncov_analysis/individual_dynamics_estimates/library")
+# library(flexsurv, lib.loc="./Assets/ncov_analysis/individual_dynamics_estimates/library")
+# library(ggplot2, lib.loc="./Assets/ncov_analysis/individual_dynamics_estimates/library")
+# #library(survminer)
+# #library(cowplot)
+# library(gridExtra, lib.loc="./Assets/ncov_analysis/individual_dynamics_estimates/library")
+system('apt-get update -y libcurl4-openssl-dev libxml2-dev libssl-dev --fix-missing')
+
+packages = c("tidyverse","survival","flexsurv","ggplot2","gridExtra")
+for(i in packages){
+  if(!require(i, character.only = T)){
+    install.packages(i)
+    library(i, character.only = T)
+  }
+}
+
+
+linelist <- read.csv('./Assets/Kudos to DXY.cn Last update_ 01_25_2020,  11_30 am (EST) - Line-list.csv', header=TRUE)
+linelist$date <- as.Date(linelist$date)
+linelist$symptom_onset <- as.Date(linelist$symptom_onset)
+linelist$hosp_visit_date <- as.Date(linelist$hosp_visit_date)
+linelist$exposure_start <- as.Date(linelist$exposure_start)
+linelist$exposure_end <- as.Date(linelist$exposure_end)
+
+
+
+# incubation = duration from exposure to onset
+# censored survival analysis
+
+t1 <- as.numeric(linelist$symptom_onset - linelist$exposure_end)
+t1 <- pmax(1,t1)
+t2 <- as.numeric(linelist$symptom_onset - linelist$exposure_start)
+st <- data.frame(t1=t1,t2=t2,status=3)
+
+st<- st[!is.na(st$t1) | !is.na(st$t2),]
+
+surv_object <- Surv(time = st$t1,
+                    time2 = st$t2, 
+                    type='interval2')
+
+mod <- survfit(surv_object~1,data=st)
+plot(mod)
+
+mod2<-flexsurvreg(surv_object ~ 1, dist="exponential", data=st)
+ggflexsurvplot(mod2,conf.int = TRUE) 
+mod2
+
+mod2a<-flexsurvreg(surv_object ~ 1, dist="weibull", data=st)
+ggflexsurvplot(mod2,conf.int = TRUE) 
+
+
+mod3<-flexsurvreg(surv_object ~ 1, dist="lognormal", data=st)
+ggflexsurvplot(mod3,conf.int = TRUE, summary.flexsurv = summary(mod3,t=seq(1,20,by=0.1))) 
+mod3
+
+predMod <- as.data.frame(summary(mod3,t=seq(1,100,by=0.1)))
+
+kmp <- ggsurvplot(mod,risk.table = TRUE, xlim=c(0,20), conf.int = FALSE) + guides(color=FALSE) 
+
+p1<-kmp$plot + geom_line(data=predMod,aes(x=time,y=est)) +
+  geom_line(data=predMod,aes(x=time,y=lcl),linetype='dashed') + 
+  geom_line(data=predMod,aes(x=time,y=ucl),linetype='dashed') + 
+  scale_x_continuous(limits=c(0,20), breaks=seq(0,20,by=2)) + 
+  xlab('') + ylab('probability')
+
+p2<- kmp$table + scale_x_continuous(limits=c(0,20), breaks=seq(0,20,by=2)) + 
+  xlab('days from exposure to symptom onset') + ylab('')
+
+plot_grid(p1,p2,nrow = 2, rel_heights = c(0.7,0.25), align='v')
+
+ggsave('./sitrep/incubation_period_estimate/incubation_from_linelist.png',width=5, height=5,units='in',dpi=600)
+
+incubationIntervals<-matrix(c(predMod$time[min(which(predMod$est<=0.5))], predMod$time[min(which(predMod$est<=0.975))],predMod$time[min(which(predMod$est<=0.025))],
+                              predMod$time[min(which(predMod$lcl<=0.5))], predMod$time[min(which(predMod$lcl<=0.975))],predMod$time[min(which(predMod$lcl<=0.025))],
+                              predMod$time[min(which(predMod$ucl<=0.5))], predMod$time[min(which(predMod$ucl<=0.975))],predMod$time[min(which(predMod$ucl<=0.025))]),
+                            ncol = 3)
+
+
+incubationIntervals <- data.frame(incubationIntervals,row.names = c('duration_median','duration_lower95','duration_upper95'))
+names(incubationIntervals) <- c('model_mle','model_lcl','model_ucl')
+incubationIntervals
+
+png('./sitrep/incubation_period_estimate/incubation_from_linelist_summary.png',width=5, height=1.5,units='in',res=600)
+grid.arrange(tableGrob(incubationIntervals))
+dev.off()
+

idmtools_test/inputs/regression/107/Assets/model.py

@@ -0,0 +1 @@
+print("Hello World")

idmtools_test/inputs/regression/125/Assets/model.py

@@ -0,0 +1 @@
+print("Hello World")

idmtools_test/inputs/regression/125/Assets2/dir1/model.py

@@ -0,0 +1 @@
+print("Hello World")

idmtools_test/inputs/regression/125/Assets2/dir2/model.py

@@ -0,0 +1 @@
+print("Hello World2")

idmtools_test/inputs/scheduling/hpc/WorkOrder.json

@@ -0,0 +1,7 @@
+{
+  "Command": "python -c \"print('hello test')\"",
+  "NodeGroupName": "emod_abcd",
+  "NumCores": 1,
+  "SingleNode": false,
+  "Exclusive": false
+}

idmtools_test/inputs/scheduling/slurm/WorkOrder.json

@@ -0,0 +1,11 @@
+{
+  "Command": "python -c \"print('hello test')\"",
+  "NodeGroupName": "idm_abcd",
+  "NumCores": 2,
+  "NumProcesses": 1,
+  "NumNodes": 1,
+  "Environment": {
+    "key1": "value1",
+    "key2": "value2"
+  }
+}

idmtools_test/inputs/scheduling/slurm/WorkOrder1.json

@@ -0,0 +1,11 @@
+{
+  "Command": "python3 Assets/commandline_model.py {pop_size} {pop_infected} {n_days} {rand_seed}",
+  "NodeGroupName": "idm_cd",
+  "NumCores": 1,
+  "NumProcesses": 1,
+  "NumNodes": 1,
+  "Environment": {
+    "key1": "value1",
+    "key2": "value2"
+  }
+}

idmtools_test/inputs/scheduling/slurm/WorkOrder2.json

@@ -0,0 +1,13 @@
+{
+  "Command": "python3 Assets/model.py",
+  "NodeGroupName": "idm_abcd",
+  "NumCores": 1,
+  "NumProcesses": 1,
+  "NumNodes": 1,
+  "Environment": {
+    "key1": "value1",
+    "key2": "value2",
+    "PYTHONPATH": "$PYTHONPATH:$PWD/Assets:$PWD/Assets/site-packages",
+    "PATH": "$PATH:$PWD/Assets:$PWD/Assets/site-packages"
+  }
+}

idmtools_test/inputs/scheduling/slurm/commandline_model.py

@@ -0,0 +1,22 @@
+import sys
+import time
+
+
+def test_sweep(pop_size=10000, pop_infected=10, n_days=120, rand_seed=1, pop_type='hybrid'):
+    pars = {
+        "pop_size": pop_size,  # Population size
+        "pop_infected": pop_infected,  # Number of initial infections
+        "n_days": n_days,  # Number of days to simulate
+        "rand_seed": rand_seed,  # Random seed
+        "pop_type": pop_type,  # Population to use -- "hybrid" is random with household, school,and work structure
+    }
+    print(str(pars))
+
+
+if __name__ == "__main__":
+    pop_size= sys.argv[1]
+    pop_infected = sys.argv[2]
+    n_days = int(sys.argv[3])
+    rand_seed = sys.argv[4]
+
+    test_sweep(pop_size=pop_size, pop_infected=pop_infected, n_days=n_days, rand_seed=rand_seed, pop_type='hybrid')

idmtools_test/inputs/serialization/single_node_demographics.json

@@ -0,0 +1,82 @@
+{
+    "Metadata": {
+        "Author": "jsteinkraus", 
+        "DateCreated": "Sun Sep 25 23:19:55 2011", 
+        "IdReference": "Gridded world grump2.5arcmin", 
+        "NodeCount": 1, 
+        "Tool": "convertdemog.py"
+    }, 
+    "Nodes": [
+        {
+            "IndividualAttributes": {
+                "AgeDistributionFlag": 3,
+                "AgeDistribution1": 0.000118,
+                "AgeDistribution2": 0,
+                "ImmunityDistribution1": 1, 
+                "ImmunityDistribution2": 0, 
+                "ImmunityDistributionFlag": 0, 
+                "MigrationHeterogeneityDistribution1": 1, 
+                "MigrationHeterogeneityDistribution2": 0, 
+                "MigrationHeterogeneityDistributionFlag": 0, 
+                "MortalityDistribution": {
+                    "AxisNames": [
+                        "gender", 
+                        "age"
+                    ], 
+                    "AxisScaleFactors": [
+                        1, 
+                        365
+                    ], 
+                    "AxisUnits": [
+                        "male=0,female=1", 
+                        "years"
+                    ], 
+                    "NumDistributionAxes": 2, 
+                    "NumPopulationGroups": [
+                        2, 
+                        1
+                    ], 
+                    "PopulationGroups": [
+                        [
+                            0, 
+                            1
+                        ], 
+                        [
+                            0
+                        ]
+                    ], 
+                    "ResultScaleFactor": 2.74e-06, 
+                    "ResultUnits": "annual deaths per 1000 individuals", 
+                    "ResultValues": [
+                        [
+                            45
+                        ], 
+                        [
+                            45
+                        ]
+                    ]
+                }, 
+                "PrevalenceDistribution1": 0.1,
+                "PrevalenceDistribution2": 0,
+                "PrevalenceDistributionFlag": 0,
+                "RiskDistribution1": 1,
+                "RiskDistribution2": 0,
+                "RiskDistributionFlag": 0
+            }, 
+            "NodeAttributes": {
+                "AbovePoverty": 0.5, 
+                "Airport": 0, 
+                "Altitude": 0, 
+                "BirthRate": 0.1234,
+                "Birth_Rate_Dependence": "FIXED_BIRTH_RATE",
+                "InitialPopulation": 1000, 
+                "Latitude": -8.5, 
+                "Longitude": 36.5, 
+                "Region": 1, 
+                "Seaport": 0, 
+                "Urban": 0
+            }, 
+            "NodeID": 340461476
+        }
+    ]
+}

idmtools_test/inputs/singularity/alpine_simple/Singularity.def

@@ -0,0 +1,28 @@
+Bootstrap: docker
+From: python:3.8.6
+
+%setup
+    mkdir /model
+
+%files
+    Assets/run_model.py /model/
+
+%post
+    apt-get -y update && apt-get install -y gcc
+    pip3 install wheel
+    pip3 install epistoch==0.1.13
+
+%runscript
+    echo "Container was created $NOW"
+    echo "Arguments received: $*"
+    exec "$@"
+
+%environment
+    export MPLBACKEND=Agg
+
+%labels
+    Author ccollins@idmod.org
+    Version v0.0.1
+
+%help
+    This is a demo container used to demo idmtools builds

idmtools_test/inputs/singularity/alpine_simple/run_model.py

@@ -0,0 +1,41 @@
+import argparse
+from epistoch import *
+from epistoch.utils.plotting import plot_sir
+from scipy import stats
+import matplotlib.pyplot as plt
+
+
+
+def run_sir_model(population, num_days, r0):
+    # Let's build a SIR-G model
+
+    dist = stats.gamma(a=2, scale=10)
+    # The expected time is 20 days
+
+    SIR_general = sir_g(
+        name="SIR-G-Example",
+        population=population,
+        num_days=num_days,
+        reproductive_factor=r0,
+        infectious_time_distribution=dist,
+        method="loss",
+    )
+
+    # Report a summary
+    report_summary(SIR_general)
+
+    # Now plot the result
+    plot_sir(SIR_general)
+    plt.savefig("result.png")
+
+    print(SIR_general["data"])
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--population", default=1000, type=int, help="Population")
+    parser.add_argument("--num-days", default=230, type=int, help="Num of days")
+    parser.add_argument("--r0", default=2.2, type=float, help="Reproduction Factory")
+
+    args = parser.parse_args()
+    run_sir_model(args.population, args.num_days, args.r0)

idmtools_test/inputs/singularity/alpine_template/Singularity.jinja

@@ -0,0 +1,22 @@
+Bootstrap: docker
+From: python:{{ python_version }}
+
+%post
+    apt-get -y update && apt-get install -y gcc
+    pip3 install wheel
+    pip3 install {% for package in packages %}{{package}} {% endfor %}
+
+%runscript
+    echo "Container was created $NOW"
+    echo "Arguments received: $*"
+    exec "$@"
+
+%environment
+    export MPLBACKEND=Agg
+
+%labels
+    Author ccollins@idmod.org
+    Version v0.0.1
+
+%help
+    This is a demo container used to demo idmtools templates

idmtools_test/test_precreate_hooks.py

@@ -0,0 +1,25 @@
+import os
+import contextlib
+from idmtools.core import TRUTHY_VALUES, getLogger
+from idmtools.registry.hook_specs import function_hook_impl
+
+TEST_WITH_NEW_CODE = os.environ.get("TEST_WITH_PACKAGES", 'n').lower() in TRUTHY_VALUES
+logger = getLogger(__name__)
+
+
+# Make a plugin here to load our local packages if needed to test CLI functions
+@function_hook_impl
+def idmtools_platform_pre_create_item(item: 'IEntity', **kwargs):
+    # do it dynamically
+    load_packages_to_ssmt_image_dynamically(item)
+
+
+def load_packages_to_ssmt_image_dynamically(item):
+    with contextlib.suppress(ImportError):
+        from idmtools_platform_comps.utils.assetize_output.assetize_output import AssetizeOutput
+        from idmtools_platform_comps.utils.download.download import DownloadWorkItem
+        from idmtools_test.utils.comps import load_library_dynamically
+        if os.environ.get("TEST_WITH_PACKAGES", 'n').lower() in TRUTHY_VALUES:
+            logger.debug("TEST WITH NEW CODE is enabled. Adding COMPS and IDMTOOLS package to asset")
+            if isinstance(item, (AssetizeOutput, DownloadWorkItem)):
+                item.add_pre_creation_hook(load_library_dynamically)

idmtools_test/utils/cli.py

@@ -0,0 +1,41 @@
+from typing import List, Dict
+
+from click.testing import CliRunner, Result
+
+
+def get_subcommands_from_help_result(result):
+    lines = striped_cli_output_lines(result)
+    found_commands_header = False
+    while not found_commands_header:
+        nex = lines.pop(0)
+        if nex == "Commands:":
+            found_commands_header = True
+    # filter down to just the name
+    lines = [l.split(None, 1)[0].strip() for l in lines]
+    return lines
+
+
+def striped_cli_output_lines(result):
+    return list(filter(lambda x: len(x), map(str.strip, result.output.split('\n'))))
+
+
+def invoke_command(*args, start_command=None, mix_stderr: bool = True, env: Dict[str, str] = None):
+    if env is None:
+        env = dict()
+    if start_command is None:
+        start_command = []
+    from idmtools_cli.main import start
+    from idmtools_cli.cli.entrypoint import cli
+    start()
+    runner = CliRunner(mix_stderr=mix_stderr, env=env)
+    final_command = start_command + list(args) if len(args) else start_command
+    result = runner.invoke(cli, final_command, env=env)
+    return result
+
+
+def run_command(*args: str, start_command: List[str] = None, base_command: str = None, mix_stderr: bool = True, env: Dict[str, str] = None) -> Result:
+    if start_command is None:
+        start_command = []
+    if base_command:
+        start_command.append(base_command)
+    return invoke_command(*args, start_command=start_command, mix_stderr=mix_stderr, env=env)

idmtools_test/utils/common_experiments.py

@@ -0,0 +1,79 @@
+import os
+
+from idmtools.assets import AssetCollection
+from idmtools.core import EntityStatus
+from idmtools.entities.experiment import Experiment
+from idmtools.entities.templated_simulation import TemplatedSimulations
+from idmtools_test import COMMON_INPUT_PATH
+
+
+def get_model_py_templated_experiment(case_name: str, default_parameters: dict = None,
+                                      assets_path: str = os.path.join(COMMON_INPUT_PATH, "python", "Assets",
+                                                                      "MyExternalLibrary"),
+                                      relative_path="MyExternalLibrary", templated_simulations=None) -> Experiment:
+    """
+    Returns an experiment using inputs/python/model.py and a JSONConfiguredPythonTask as the task
+
+    Args:
+        case_name: Test case name
+        default_parameters: Default parameters from model
+        assets_path: Default path to assets
+        relative_path: Relative path to add to assets
+        templated_simulations:Optional override for templated simulations
+
+    Returns:
+
+    """
+    from idmtools_models.python.json_python_task import JSONConfiguredPythonTask
+
+    if default_parameters is None:
+        default_parameters = dict()
+    model_path = os.path.join(COMMON_INPUT_PATH, "python", "model.py")
+    ac = AssetCollection()
+    ac.add_directory(assets_directory=assets_path, relative_path=relative_path)
+    task = JSONConfiguredPythonTask(script_path=model_path, envelope="parameters", parameters=default_parameters)
+    if templated_simulations is None:
+        templated_simulations = TemplatedSimulations(base_task=task)
+    e = Experiment(name=case_name, simulations=templated_simulations, assets=ac)
+    # assets=AssetCollection.from_directory(assets_directory=assets_path, relative_path="MyExternalLibrary"))
+    e.tags = {"string_tag": "test", "number_tag": 123}
+    return e
+
+
+def get_model1_templated_experiment(case_name, parameters=None):
+    from idmtools_models.python.json_python_task import JSONConfiguredPythonTask
+    if parameters is None:
+        parameters = dict(c='c-value')
+    model_path = os.path.join(COMMON_INPUT_PATH, "python", "model1.py")
+    e = Experiment(name=case_name,
+                   simulations=TemplatedSimulations(base_task=JSONConfiguredPythonTask(parameters=parameters,
+                                                                                       script_path=model_path)
+                                                    ))
+    e.tags = {"string_tag": "test", "number_tag": 123, "KeyOnly": None}
+    return e
+
+
+def wait_on_experiment_and_check_all_sim_status(tc, experiment, platform=None,
+                                                expected_status: EntityStatus = EntityStatus.SUCCEEDED,
+                                                scheduling=False):
+    """
+    Run experiment and wait for it to finish then check all sims succeeded
+    Args:
+        tc: Test case(self)
+        experiment: Experiment object
+        platform: Platform
+        expected_status: Expected status
+    Returns:
+
+    """
+    experiment.run(wait_until_done=True, scheduling=scheduling, retries=5)
+    if isinstance(tc, type):
+        tc.assertTrue(tc, all([s.status == expected_status for s in experiment.simulations]))
+    else:
+        tc.assertTrue(all([s.status == expected_status for s in experiment.simulations]))
+        if expected_status is EntityStatus.SUCCEEDED:
+            tc.assertTrue(experiment.done)
+            tc.assertTrue(experiment.succeeded)
+        elif expected_status is EntityStatus.FAILED:
+            tc.assertFalse(experiment.succeeded)
+    return experiment