PycWB 0.25.0__tar.gz → 0.26.0__tar.gz

{pycwb-0.25.0 → pycwb-0.26.0}/.gitlab-ci.yml

@@ -20,7 +20,7 @@ image: buildpack-deps:jammy
 stages:          # List of stages for jobs, and their order of execution
   - build
   - deploy
-  - post-deploy
+  #- post-deploy
 
 .install_common: &install_common
   - wget -q https://root.cern/download/root_v6.26.14.Linux-ubuntu22-x86_64-gcc11.4.tar.gz
@@ -64,23 +64,24 @@ publish:
     - pip install twine
     - TWINE_PASSWORD=${PYPI_TOKEN} TWINE_USERNAME=__token__ python -m twine upload dist/*.tar.gz
 
-pages:
-  stage: post-deploy
-  rules:
-    - changes:
-        - docs/**/*
-    - if: '$CI_COMMIT_TAG'
-  script:
-    - *install_common
-    - pip install pycwb
-    - ln -fs /usr/share/zoneinfo/Etc/UTC /etc/localtime
-    - pip install "sphinx<7.0.0" sphinx_rtd_theme
-    - make doc
-    - mkdir public
-    - cp -r docs/build/html/* public/
-  artifacts:
-    paths:
-      - public
+#pages:
+#  stage: post-deploy
+#  rules:
+#    - changes:
+#        - docs/**/*
+#    - if: '$CI_COMMIT_TAG'
+#  script:
+#    - *install_common
+#    - pip install pycwb
+#    - ln -fs /usr/share/zoneinfo/Etc/UTC /etc/localtime
+#    - pip install "sphinx<7.0.0" sphinx_rtd_theme
+#    - make doc
+#    - mkdir public
+#    - cp -r docs/build/html/* public/
+#  artifacts:
+#    paths:
+#      - public
+
 #test-job:   # This job runs in the test stage.
 #  image: continuumio/miniconda3
 #  stage: test    # It only starts when the job in the build stage completes successfully.

{pycwb-0.25.0 → pycwb-0.26.0}/.readthedocs.yaml

@@ -4,6 +4,9 @@ build:
   os: "ubuntu-22.04"
   tools:
     python: "mambaforge-22.9"
+  jobs:
+    pre_install:
+      - git update-index --assume-unchanged envs/environment.yml docs/source/conf.py
 
 conda:
   environment: envs/environment.yml

{pycwb-0.25.0 → pycwb-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.25.0
+Version: 0.26.0
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.25.0 → pycwb-0.26.0}/PycWB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.25.0
+Version: 0.26.0
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.25.0 → pycwb-0.26.0}/PycWB.egg-info/SOURCES.txt

@@ -231,6 +231,9 @@ prototypes/messenger-web-interface/src/views/nodes/node3.vue
 prototypes/messenger-web-interface/src/views/nodes/nodeHeader.vue
 prototypes/performance/numba_test.py
 prototypes/performance/taichi_test.py
+prototypes/pp_workflow/simple.yaml
+prototypes/pp_workflow/simple_module.yaml
+prototypes/pp_workflow/workflow.yaml
 pycwb/__init__.py
 pycwb/_version.py
 pycwb/cli/__init__.py
@@ -238,6 +241,7 @@ pycwb/cli/batch_runner.py
 pycwb/cli/batch_setup.py
 pycwb/cli/flow.py
 pycwb/cli/merge_catalog.py
+pycwb/cli/post_process.py
 pycwb/cli/run.py
 pycwb/cli/server.py
 pycwb/cli/xtalk.py
@@ -322,6 +326,10 @@ pycwb/modules/read_data/read_data.py
 pycwb/modules/reconstruction/__init__.py
 pycwb/modules/reconstruction/getMRAwaveform.py
 pycwb/modules/reconstruction/module.yaml
+pycwb/modules/report/__init__.py
+pycwb/modules/report/far_rho.py
+pycwb/modules/report/read_results.py
+pycwb/modules/report/report.py
 pycwb/modules/sparse_series/__init__.py
 pycwb/modules/sparse_series/module.yaml
 pycwb/modules/sparse_series/sparse_table.py
@@ -350,6 +358,8 @@ pycwb/modules/xtalk/__init__.py
 pycwb/modules/xtalk/monster.py
 pycwb/modules/xtalk/monster_old.py
 pycwb/modules/xtalk/xtalk_data.py
+pycwb/post_production/__init__.py
+pycwb/post_production/workflow.py
 pycwb/prefect_flow/__init__.py
 pycwb/prefect_flow/pycwb_flow.py
 pycwb/prefect_flow/tasks/__init__.py

{pycwb-0.25.0 → pycwb-0.26.0}/bin/pycwb

@@ -11,6 +11,7 @@ import pycwb.cli.batch_setup as batch_setup
 import pycwb.cli.batch_runner as batch_runner
 import pycwb.cli.xtalk as xtalk
 import pycwb.cli.merge_catalog as merge_catalog
+import pycwb.cli.post_process as post_process
 
 def main():
     parser = argparse.ArgumentParser(prog='pycwb')
@@ -46,6 +47,10 @@ def main():
     merge_catalog.init_parser(merge_catalog_parser)
     merge_catalog_parser.set_defaults(func=merge_catalog.command)
 
+    post_process_parser = subparsers.add_parser('post-process', help='Post process the results')
+    post_process.init_parser(post_process_parser)
+    post_process_parser.set_defaults(func=post_process.command)
+
     args = parser.parse_args()
     if hasattr(args, 'func'):
         args.func(args)

pycwb-0.26.0/prototypes/pp_workflow/simple.yaml

@@ -0,0 +1,43 @@
+global:
+  work_dir: /Users/yumengxu/Downloads/pycwb_examples
+steps:
+  - action: read_triggers
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]>0"
+    output_alias: 'background'
+  - action: read_live_time
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]>0"
+    output_alias: 'livetime'
+  - action: far_rho # this module will calculate the ifar_rho and pass the output to the downstream modules
+    args:
+      source: 'background'
+      livetime_key: 'livetime'
+      ranking_par: rho[0]
+      bin_size: 0.0001
+    output_alias: 'far_rho'
+  - action: read_triggers
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]==0"
+    output_alias: 'zero_lag'
+  - action: read_live_time
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]==0"
+    output_alias: 'livetime_zerolag'
+  - action: report_zero_lag
+    args:
+      source: 'zero_lag'
+      livetime_key: 'livetime_zerolag'
+      far_rho_source: 'far_rho'
+  - action: report # generate report
+    args:
+      far_rho_source: 'far_rho'
+      output: public/

pycwb-0.26.0/prototypes/pp_workflow/simple_module.yaml

@@ -0,0 +1,44 @@
+global:
+  work_dir: /Users/yumengxu/Downloads/pycwb_examples
+steps:
+  - action: report.read_results.read_triggers
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]>0"
+    output_alias: 'background'
+  - action: report.read_results.read_live_time
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]>0"
+    output_alias: 'livetime'
+  - action: report.far_rho.far_rho # this module will calculate the far_rho and pass the output to the downstream modules
+    args:
+      source: 'background'
+      livetime_key: 'livetime'
+      ranking_par: rho[0]
+      bin_size: 0.0001
+      save: far_rho.json
+    output_alias: 'far_rho'
+  - action: report.read_results.read_triggers
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]==0"
+    output_alias: 'zero_lag'
+  - action: report.read_results.read_live_time
+    args:
+      run_dir: background
+      filters:
+        - "lag[0]==0"
+    output_alias: 'livetime_zerolag'
+  - action: report.report.report_zero_lag
+    args:
+      source: 'zero_lag'
+      livetime_key: 'livetime_zerolag'
+      far_rho_source: 'far_rho'
+  - action: report.report.report # generate report
+    args:
+      far_rho_source: 'far_rho'
+      output: public/

pycwb-0.26.0/prototypes/pp_workflow/workflow.yaml

@@ -0,0 +1,40 @@
+global:
+  work_dir: /Users/yumengxu/Downloads/pycwb_examples/non-builtin-waveform
+steps:
+  - action: events_filter # this module will filter the event and pass to the downstream modules
+    args:
+      run_dir: O4_K01_BurstLD_BKG
+      conditions:
+        - "lag>0" # only process non-zero lag events
+    output_alias: 'background'
+  - action: events_filter # read the training set and name it as 'training_set'
+    args:
+      run_dir: O4_K01_BurstLD_SIM_TrainingSet1
+    output_alias: 'sim_training_set'
+  - action: events_splitter # split the background into bkg_training_set and bkg_test_set
+    args:
+      source: 'background'
+      percent: [0.5, 0.5]
+    output_alias: ['bkg_training_set', 'bkg_test_set']
+  - action: xgboost_model # take the training set from the upsteam
+    args:
+      background: ['bkg_training_set']
+      simulation: ['sim_training_set']
+      config: xgb_config.py
+      get_rhor: xgb_get_rhor.py
+      name: 'model_v1a'
+  - action: xgboost_apply # apply xgb on BKG
+    args:
+      source: 'bkg_test_set'
+      model: 'model_v1a'
+    output_alias: 'bkg_test_set.model_v1a'
+  - action: ifar_rho # this module will calculate the ifar_rho and pass the output to the downstream modules
+    args:
+      source: 'bkg_test_set.model_v1a'
+      ranking_par: rho[1]
+      ranking_par_bin: 0.0001
+    output_alias: 'bkg_test_set.model_v1a.ifar'
+  - action: report # generate report
+    args:
+      source: 'bkg_test_set.model_v1a.ifar'
+    output: public/

{pycwb-0.25.0 → pycwb-0.26.0}/pycwb/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.25.0'
-__version_tuple__ = version_tuple = (0, 25, 0)
+__version__ = version = '0.26.0'
+__version_tuple__ = version_tuple = (0, 26, 0)

pycwb-0.26.0/pycwb/cli/post_process.py

@@ -0,0 +1,15 @@
+import os
+
+
+def init_parser(parser):
+    # Add the arguments
+    parser.add_argument('workflow_file',
+                        metavar='file_path',
+                        type=str,
+                        help='the path to the workflow file')
+
+
+def command(args):
+    from pycwb.post_production.workflow import run_workflow
+
+    run_workflow(args.workflow_file)

{pycwb-0.25.0 → pycwb-0.26.0}/pycwb/modules/likelihood/likelihood.py

@@ -11,7 +11,8 @@ from pycwb.types.network_event import Event
 logger = logging.getLogger(__name__)
 
 
-def likelihood(config, network, fragment_cluster, lag=0) -> tuple[list[Event], list[Cluster], list[dict]]:
+def likelihood(config, network, fragment_cluster, lag=0, shifts=(0,0,0), job_id=None) \
+        -> tuple[list[Event], list[Cluster], list[dict]]:
     """
     calculate likelihood for single lag
 
@@ -56,7 +57,8 @@ def likelihood(config, network, fragment_cluster, lag=0) -> tuple[list[Event], l
             continue
 
         cluster_id = k + 1
-        event, cluster = _likelihood(config, network, lag, cluster_id, fragment_cluster.dump_cluster(k))
+        event, cluster = _likelihood(config, network, lag, cluster_id, fragment_cluster.dump_cluster(k), shifts)
+        event.job_id = job_id
         events.append(event)
         clusters.append(cluster)
 
@@ -106,7 +108,7 @@ def likelihood(config, network, fragment_cluster, lag=0) -> tuple[list[Event], l
     return events, clusters, skymap_statistics
 
 
-def _likelihood(config, network, lag, cluster_id, fragment_cluster):
+def _likelihood(config, network, lag, cluster_id, fragment_cluster, shifts=(0,0,0)):
     # dumb variables
     k = 0
 
@@ -149,7 +151,7 @@ def _likelihood(config, network, lag, cluster_id, fragment_cluster):
     cluster = convert_netcluster_to_fragment_clusters(network.get_cluster(lag)).clusters[0]
 
     event = Event()
-    event.output(network.net, k + 1, lag)
+    event.output(network.net, k + 1, lag, shifts=shifts)
 
     pwc.clean(1)
 

pycwb-0.26.0/pycwb/modules/report/far_rho.py

@@ -0,0 +1,50 @@
+import numpy as np
+import orjson
+
+
+def far_rho(source, ranking_par, bin_size, livetime_key='livetime', save='far_rho.json', **kwargs):
+    print(f"Calculating far and rho for source {source} with ranking parameter {ranking_par} with bin size {bin_size}")
+
+    if source not in kwargs:
+        print(f"Source {source} not found in the results")
+        raise ValueError(f"Source {source} not found in the results")
+    triggers = kwargs[source]
+
+    if livetime_key not in kwargs:
+        print(f"Live time key {livetime_key} not found in the results")
+        raise ValueError(f"Live time key {livetime_key} not found in the results")
+    livetime = kwargs[livetime_key]
+
+    # extract the ranking parameter from the triggers
+    if '[' not in ranking_par:
+        values = [trigger[ranking_par] for trigger in triggers]
+    else:
+        base_key, index = ranking_par.split('[')
+        index = int(index.rstrip(']'))
+        values = [trigger[base_key][index] for trigger in triggers]
+
+    # remove None in values and print warning with trigger job_id and id
+    none_values = [triggers[i] for i, value in enumerate(values) if value is None]
+    if none_values:
+        print(f"Warning: {len(none_values)} triggers with None value in {ranking_par}")
+        for none_value in none_values:
+            print(none_value)
+
+    values = [value for value in values if value is not None]
+
+    # calculate the n_events vs rho
+    hist, bins = np.histogram(values, bins=np.arange(min(values), max(values) + bin_size, bin_size))
+    accumulate_hist = np.cumsum(hist[::-1])[::-1]
+    bins = bins[:-1]
+
+    # calculate the far for each bin
+    livetime_in_years = livetime / 86400 / 365.25
+    far = [accumulate_hist[i] / livetime_in_years for i in range(len(accumulate_hist))]
+    data = {'bins': bins, 'far': far, 'n_events': hist,
+            'ranking_par': ranking_par, 'source': source, 'livetime': livetime}
+
+    if save:
+        with open(save, 'wb') as f:
+            f.write(orjson.dumps(data, option=orjson.OPT_SERIALIZE_NUMPY))
+
+    return data

pycwb-0.26.0/pycwb/modules/report/read_results.py

@@ -0,0 +1,79 @@
+from concurrent.futures import ThreadPoolExecutor
+import orjson
+import os
+import numpy as np
+
+
+def read_catalog(catalog_file):
+    with open(catalog_file, 'rb') as f:
+        catalog = orjson.loads(f.read())
+
+    # remove redundant events (unique event['id']) in catalog
+    n_events_before = len(catalog['events'])
+    catalog['events'] = list({f"{event['job_id']}_{event['id']}": event for event in catalog['events']}.values())
+    n_events_after = len(catalog['events'])
+    if n_events_before != n_events_after:
+        print(f"Removed {n_events_before - n_events_after} duplicated events")
+    return catalog
+
+def read_event(event_file):
+    with open(event_file, 'rb') as f:
+        events = orjson.loads(f.read())
+    return events
+
+def list_dict_filter(data, conditions, name='event'):
+    print(f"number of {name} before filtering: {len(data)}")
+    filter_string = " and ".join(conditions)
+    print(f"Performing filter: {filter_string}")
+    filtered_events = [d for d in data if eval(filter_string, {"__builtins__": None}, d)]
+    print(f"number of {name} after filtering: {len(filtered_events)}")
+    return filtered_events
+
+def read_triggers(work_dir, run_dir, filters=None, file='catalog/catalog.json',**kwargs):
+    print(f"Reading results from {os.path.join(work_dir, run_dir, file)}")
+    catalog = read_catalog(os.path.join(work_dir, run_dir, file))
+
+    events = []
+    n_events = len(catalog['events'])
+    # for i, event in enumerate(catalog['events']):
+    #     if i % 100 == 0:
+    #         print(f"Reading event {i}/{n_events}", end='\r')
+    #     event_file = os.path.join(work_dir, run_dir, f"trigger/trigger_{event['job_id']}_{event['id']}/event.json")
+    #     events.append(read_event(event_file))
+
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(read_event, os.path.join(work_dir, run_dir, f"trigger/trigger_{event['job_id']}_{event['id']}/event.json"))
+                   for event in catalog['events']]
+        for i, future in enumerate(futures):
+            if i % 100 == 0:
+                print(f"Reading event {i}/{n_events}", end='\r')
+            events.append(future.result())
+    if filters:
+        events = list_dict_filter(events, filters, name='triggers')
+    return events
+
+
+def read_live_time(work_dir, run_dir, filters=None, file='catalog/catalog.json',**kwargs):
+    print(f"Reading live time from {os.path.join(work_dir, run_dir, file)}")
+    catalog = read_catalog(os.path.join(work_dir, run_dir, file))
+
+    # TODO: this is for the simplest case only
+    lags = np.arange(catalog['config']['lagSize'])
+
+    livetimes = []
+    for job in catalog['jobs']:
+        shift = job['shift']
+        livetime_single = job['end_time'] - job['start_time']
+        for lag in lags:
+            livetimes.append({
+                'shift': shift,
+                'livetime': livetime_single,
+                'lag': lag
+            })
+
+    if filters:
+        livetimes = list_dict_filter(livetimes, filters, name='live times')
+
+    total_live_time = sum([lt['livetime'] for lt in livetimes])
+    print(f"Total live time: {total_live_time}s ({total_live_time/86400:.2f} days, {total_live_time/86400/365:.2f} years)")
+    return total_live_time

pycwb-0.26.0/pycwb/modules/report/report.py

@@ -0,0 +1,120 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.stats import poisson
+
+
+def report(far_rho_source=None, **kwargs):
+
+    print(f"Reporting the results")
+    if far_rho_source:
+        if far_rho_source not in kwargs:
+            print(f"Source {far_rho_source} not found in the results")
+            raise ValueError(f"Source {far_rho_source} not found in the results")
+        data = kwargs[far_rho_source]
+
+        # plot the far vs ranking parameter
+        plt.plot(data['bins'], data['far'], drawstyle='steps-post')
+        plt.xlabel(data['ranking_par'])
+        plt.ylabel('far')
+        plt.yscale('log')
+        plt.savefig(f"{far_rho_source}.png")
+        plt.close()
+
+        # plot the number of events vs ranking parameter
+        plt.plot(data['bins'], data['n_events'], drawstyle='steps-post')
+        plt.xlabel(data['ranking_par'])
+        plt.ylabel('number of events')
+        plt.yscale('log')
+        plt.savefig(f"{far_rho_source}_n_events.png")
+        plt.close()
+
+
+def report_zero_lag(source, livetime_key='livetime_zerolag', far_rho_source='far_rho', **kwargs):
+    print(f"Reporting the zero lag results")
+    if source not in kwargs:
+        print(f"Source {source} not found in the results")
+        raise ValueError(f"Source {source} not found in the results")
+    triggers = kwargs[source]
+
+    if livetime_key not in kwargs:
+        print(f"Live time key {livetime_key} not found in the results")
+        raise ValueError(f"Live time key {livetime_key} not found in the results")
+    livetime = kwargs[livetime_key]
+
+    if far_rho_source not in kwargs:
+        print(f"Source {far_rho_source} not found in the results")
+        raise ValueError(f"Source {far_rho_source} not found in the results")
+    far_rho_data = kwargs[far_rho_source]
+
+    # attach far to the triggers if the trigger's ranking_par is within the range of bin
+    ranking_par = far_rho_data['ranking_par']
+    bins = far_rho_data['bins']
+    far = far_rho_data['far']
+
+    if '[' not in ranking_par:
+        values = [trigger[ranking_par] for trigger in triggers]
+    else:
+        base_key, index = ranking_par.split('[')
+        index = int(index.rstrip(']'))
+        values = [trigger[base_key][index] for trigger in triggers]
+
+    # remove None in values and print warning with trigger job_id and id
+    none_values = [triggers[i] for i, value in enumerate(values) if value is None]
+    if none_values:
+        print(f"Warning: {len(none_values)} triggers with None value in {ranking_par}")
+        for none_value in none_values:
+            print(none_value)
+    triggers = [triggers[i] for i, value in enumerate(values) if value is not None]
+    values = [value for value in values if value is not None]
+
+    # align the values to the bin
+    bin_indices = np.digitize(values, bins) - 1
+    far_values = [far[i] for i in bin_indices]
+    for i, trigger in enumerate(triggers):
+        trigger['far'] = far_values[i]
+
+    # plot the triggers far vs ranking parameter
+    print(f"Plotting far vs {ranking_par}")
+    plt.scatter(values, far_values)
+    plt.xlabel(ranking_par)
+    plt.ylabel('far')
+    plt.yscale('log')
+    plt.savefig(f"{source}_far.png")
+    plt.close()
+
+    print(f"Plotting far vs n_events accumulative distribution")
+    # plot accumulated triggers vs trigger['far']
+    ranked_triggers = sorted(triggers, key=lambda x: 1/x['far'], reverse=True)
+    ifar = np.array([1/trigger['far'] for trigger in ranked_triggers])
+    plot_y = np.arange(1, len(ranked_triggers) + 1)
+    plt.plot(ifar, plot_y, drawstyle='steps-post')
+
+    livetime_in_years = livetime / 86400 / 365.25
+    ifar_min = min(ifar)
+    n_events_at_ifar_min = livetime_in_years / ifar_min
+    ifar_max = max(ifar)
+    n_events_at_ifar_max = livetime_in_years / ifar_max
+    plt.plot([ifar_min, ifar_max], [n_events_at_ifar_min, n_events_at_ifar_max], color='black', linewidth=0.5)
+    print(f"ifar_min: {ifar_min}, n_events_at_ifar_min: {n_events_at_ifar_min}")
+    print(f"ifar_max: {ifar_max}, n_events_at_ifar_max: {n_events_at_ifar_max}")
+
+    # Calculate the Poisson confidence intervals
+    # generate the ifar range which is denser at the higher ifar
+    ifar_range = np.linspace(ifar_min, ifar_max, 100000)
+    n_events_range = livetime_in_years / ifar_range
+    sigma_levels = [1, 2, 3]
+    confidence_levels = [0.6827, 0.9545, 0.9973]
+    conf_intervals = {sigma: poisson.interval(confidence, n_events_range) for sigma, confidence in zip(sigma_levels, confidence_levels)}
+    # Plot the Poisson confidence intervals
+    colors = ['gray', 'gray', 'gray']
+    for sigma, color in zip(sigma_levels, colors):
+        lower, upper = conf_intervals[sigma]
+        plt.fill_between(ifar_range, lower, upper, color=color, alpha=0.6 / sigma, label=f'{sigma} sigma', linewidth=0.4)
+
+    plt.xlabel('ifar')
+    plt.ylabel('n_events')
+    plt.xscale('log')
+    plt.yscale('log')
+    plt.legend()
+    plt.savefig(f"{source}_far_n_events.png")
+    plt.close()

pycwb-0.26.0/pycwb/post_production/workflow.py

@@ -0,0 +1,36 @@
+import yaml
+import copy
+from pycwb.utils.module import import_helper
+
+
+def run_workflow(workflow_file):
+    with open(workflow_file, 'r') as f:
+        workflow = yaml.safe_load(f)
+
+    # the global arguments will be inserted into each step,
+    # the output of each step will be stored in the global arguments
+    # if the output_alias if given, the output will be stored in the
+    # global arguments with the key of output_alias
+    global_args = workflow['global']
+    # iterate through each step
+    for step in workflow['steps']:
+        # get the function, this will be replaced with a module loader
+        func_name = step['action'].split('.')[-1]
+        module_name = '.'.join(step['action'].split('.')[:-1])
+        if not module_name.startswith('pycwb'):
+            module_name = f"pycwb.modules.{module_name}"
+        module = import_helper(module_name, module_name)
+        func = getattr(module, func_name)
+        # combine global_args and step['args']
+        args = copy.deepcopy(global_args)
+        args.update(step['args'])
+
+        print("-"*50)
+        print(f"Running action {step['action']} with args {list(args.keys())}")
+        result = func(**args)
+        if 'output_alias' in step:
+            global_args[step['output_alias']] = result
+            print(f"Output stored with key: {step['output_alias']}")
+        # if result is a dict, add to results
+        elif isinstance(result, dict):
+            global_args.update(result)