PycWB 0.24.0__tar.gz → 0.25.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.24.0
+Version: 0.25.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>
@@ -31,6 +31,7 @@ Requires-Dist: prefect-dask
 Requires-Dist: dask
 Requires-Dist: dask_jobqueue
 Requires-Dist: htcondor
+Requires-Dist: psutil
 
 # PycWB
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.24.0
+Version: 0.25.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>
@@ -31,6 +31,7 @@ Requires-Dist: prefect-dask
 Requires-Dist: dask
 Requires-Dist: dask_jobqueue
 Requires-Dist: htcondor
+Requires-Dist: psutil
 
 # PycWB
 

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

@@ -339,6 +339,7 @@ pycwb/modules/super_cluster/utils.py
 pycwb/modules/supercluster_naive/__init__.py
 pycwb/modules/supercluster_naive/supercluster2.py
 pycwb/modules/superlag/__init__.py
+pycwb/modules/superlag/module.yaml
 pycwb/modules/superlag/superlag.py
 pycwb/modules/web_viewer/__init__.py
 pycwb/modules/web_viewer/create.py
@@ -370,6 +371,7 @@ pycwb/utils/async_write.py
 pycwb/utils/check_ROOT.py
 pycwb/utils/dataclass_object_io.py
 pycwb/utils/dep_check.py
+pycwb/utils/generate_params_table.py
 pycwb/utils/image.py
 pycwb/utils/module.py
 pycwb/utils/network.py
@@ -393,5 +395,4 @@ pycwb/workflow/run.py
 pycwb/workflow/subflow/__init__.py
 pycwb/workflow/subflow/postprocess_and_plots.py
 pycwb/workflow/subflow/prepare_job_runs.py
-pycwb/workflow/subflow/process_job_segment.py
-pycwb/workflow/subflow/supercluster_and_likelihood.py
+pycwb/workflow/subflow/process_job_segment.py

{pycwb-0.24.0 → pycwb-0.25.0}/PycWB.egg-info/requires.txt

@@ -21,3 +21,4 @@ prefect-dask
 dask
 dask_jobqueue
 htcondor
+psutil

{pycwb-0.24.0 → pycwb-0.25.0}/docs/source/conf.py

@@ -27,7 +27,7 @@ exclude_patterns = ["pycwb/vendor/*", ".DS_Store"]
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = 'sphinx_rtd_theme'
+html_theme = "furo"
 html_static_path = ['_static']
 
 # -- external links ----------------------------------------------------------

pycwb-0.25.0/docs/source/schema.rst

@@ -0,0 +1,15 @@
+.. _schema:
+
+User Parameters
+----------------
+
+The default schema for user parameters is:
+
+.. exec::
+    import json
+    from pycwb.constants import user_parameters_schema
+    from pycwb.utils.generate_params_table import generate_rst_table, parse_description, parse_type_or_enum
+
+    print(generate_rst_table(user_parameters_schema["properties"]))
+    # json_obj = json.dumps(user_parameters_schema, sort_keys=True, indent=4)
+    # print('.. code-block:: JavaScript\n\n    %s\n\n' % json_obj)

{pycwb-0.24.0 → pycwb-0.25.0}/envs/environment.yml

@@ -12,4 +12,5 @@ dependencies:
   - python=3.10
   - root=6.26.10
   - setuptools_scm
-  - sphinx_rtd_theme
+  - sphinx_rtd_theme
+  - furo

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

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

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/cli/batch_setup.py

@@ -73,9 +73,25 @@ def init_parser(parser):
                         '-j',
                         metavar='job_per_worker',
                         type=int,
-                        default=5,
+                        default=1,
                         help='the number of jobs per worker')
 
+    # memory
+    parser.add_argument('--memory',
+                        '-m',
+                        metavar='memory',
+                        type=str,
+                        default='6GB',
+                        help='the memory for each job')
+
+    # disk
+    parser.add_argument('--disk',
+                        '-k',
+                        metavar='disk',
+                        type=str,
+                        default='4GB',
+                        help='the disk space for each job')
+
     # compress json
     parser.add_argument('--compress_json',
                         action='store_true',
@@ -124,6 +140,8 @@ def command(args):
                 conda_env=args.conda_env,
                 additional_init=args.additional_init,
                 n_proc=args.n_proc,
+                memory=args.memory,
+                disk=args.disk,
                 accounting_group=args.accounting_group,
                 job_per_worker=args.job_per_worker,
                 submit=args.submit,

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/catalog/catalog.py

@@ -1,7 +1,7 @@
 import os
 import logging
 from filelock import SoftFileLock
-import json
+import orjson
 import pycwb
 from pycwb.config import Config
 from pycwb.types.job import WaveSegment
@@ -32,13 +32,13 @@ def create_catalog(filename: str, config: Config, jobs: list[WaveSegment]) -> No
     output = {
         "config": config.__dict__,
         "version": pycwb.__version__,
-        "jobs": [job.to_dict() for job in jobs],
+        "jobs": jobs,
         "events": []
     }
 
     with SoftFileLock(filename + ".lock", timeout=10):
-        with open(filename, 'w') as f:
-            json.dump(output, f, default=vars)
+        with open(filename, 'wb') as f:
+            f.write(orjson.dumps(output, option=orjson.OPT_SERIALIZE_NUMPY))
 
 
 def add_events_to_catalog(filename: str, events: list[Event]) -> None:
@@ -64,13 +64,13 @@ def add_events_to_catalog(filename: str, events: list[Event]) -> None:
     if os.path.exists(filename):
         with SoftFileLock(filename + ".lock", timeout=10):
             # read the json file
-            with open(filename, 'r+') as f:
-                catalog = json.load(f)
+            with open(filename, 'rb+') as f:
+                catalog = orjson.loads(f.read())
                 # append events
                 catalog["events"].extend(events)
                 # write the json file
                 f.seek(0)
-                json.dump(catalog, f)
+                f.write(orjson.dumps(catalog, option=orjson.OPT_SERIALIZE_NUMPY))
     else:
         logger.warning("Catalog file does not exist. Event will not be saved to catalog.")
 

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/data_conditioning/whitening.py

@@ -24,6 +24,7 @@ def whitening(config, h):
     layers_white = 2 ** config.l_white if config.l_white > 0 else 2 ** config.l_high
     wdm_white = WDM(layers_white, layers_white, config.WDM_beta_order, config.WDM_precision)
 
+    # TODO: check the length of data and white parameters to prevent freezing
     # check if whitening WDM filter lenght is less than cwb scratch
     wdmFlen = wdm_white.m_H / config.rateANA
     if wdmFlen > config.segEdge + 0.001:

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/job_segment/dq_segment.py

@@ -101,7 +101,7 @@ def get_seg_list(ifo, dq_list, seg_len, seg_mls, seg_edge):
     return []
 
 
-def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
+def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate, shift=None, index_start=0):
     """
     Build the job segment list.
 
@@ -128,6 +128,10 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
     :type seg_edge:  int
     :param sample_rate:  sample rate [Hz]
     :type sample_rate:  int
+    :param shift:  list of shifts for each interferometer, used for superlags
+    :type shift:  list[float]
+    :param index_start:  index of the first segment
+    :type index_start:  int
     :return:  Return the job segment list
     :rtype:  list[WaveSegment]
     """
@@ -138,7 +142,7 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
     lostlivetime = 0
     job_list = []
 
-    seg_index = 0
+    seg_index = index_start
 
     for i in range(len(dq_list[0])):
         start = math.ceil(dq_list[0][i]) + seg_edge
@@ -154,7 +158,7 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
                 continue
             seg_index += 1
             job_list.append(WaveSegment(seg_index, ifos, start, stop,
-                                        seg_edge=seg_edge, sample_rate=sample_rate))
+                                        seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
             continue
         if n == 1:
             if length > seg_len:
@@ -163,39 +167,39 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
                 if half >= seg_mls:
                     seg_index += 1
                     job_list.append(WaveSegment(seg_index, ifos, start, start + half,
-                                                seg_edge=seg_edge, sample_rate=sample_rate))
+                                                seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
 
                     seg_index += 1
                     job_list.append(WaveSegment(seg_index, ifos, start + half, stop,
-                                                seg_edge=seg_edge, sample_rate=sample_rate))
+                                                seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
                 else:
                     seg_index += 1
                     job_list.append(WaveSegment(seg_index, ifos, start, start + seg_len,
-                                                seg_edge=seg_edge, sample_rate=sample_rate))
+                                                seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
             else:
                 seg_index += 1
                 job_list.append(WaveSegment(i, ifos, start, stop,
-                                            seg_edge=seg_edge, sample_rate=sample_rate))
+                                            seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
             continue
 
         for j in range(n - 1):
             seg_index += 1
             job_list.append(WaveSegment(seg_index, ifos, seg_len * j + start, seg_len * j + start + seg_len,
-                                        seg_edge=seg_edge, sample_rate=sample_rate))
+                                        seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
 
         remainder = stop - job_list[-1].end_time
         half = int(remainder / 2)
         if half >= seg_mls:
             seg_index += 1
             job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + half,
-                                        seg_edge=seg_edge, sample_rate=sample_rate))
+                                        seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
             seg_index += 1
             job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, stop,
-                                        seg_edge=seg_edge, sample_rate=sample_rate))
+                                        seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
         else:
             seg_index += 1
             job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + seg_len,
-                                        seg_edge=seg_edge, sample_rate=sample_rate))
+                                        seg_edge=seg_edge, sample_rate=sample_rate, shift=shift))
 
     logger.info('lost livetime after building of the standard job list = %d sec' % lostlivetime)
 

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/job_segment/frame.py

@@ -81,16 +81,16 @@ def select_frame_list(frame_list, start, stop, seg_edge):
     return frame_list
 
 
-def get_frame_files_from_gwdatafind(ifos, sites, frametypes, start, stop, seg_edge, host=None):
+def get_frame_files_from_gwdatafind(ifo, site, frametype, start, stop, seg_edge, host=None):
     """
     Use gwdatafind to get the frame files for the job segments
 
-    :param ifos: list of interferometers
-    :type ifos: list[str]
-    :param sites: list of sites
-    :type sites: list[str]
-    :param frametypes: list of frame types
-    :type frametypes: list[str]
+    :param ifo: name of the interferometer
+    :type ifo: str
+    :param site: site name of the interferometer
+    :type site: str
+    :param frametype: frame type
+    :type frametype: str
     :param start: start time of the segment
     :type start: int or float
     :param stop: stop time of the segment
@@ -109,17 +109,19 @@ def get_frame_files_from_gwdatafind(ifos, sites, frametypes, start, stop, seg_ed
     seg_stop = stop + seg_edge
 
     frame_list = []
-    for i, frametype in enumerate(frametypes):
-        url = find_urls(sites[i], frametype, seg_start, seg_stop, host=host)
-        frame_paths = [fp.replace("file://localhost", "") for fp in url]
 
-        for frame_path in frame_paths:
-            # get the file name without the extension with pathlib
-            frame_name = Path(frame_path).stem
-            # get the gps time and duration with int type
-            gps_start, duration = [int(i) for i in frame_name.split("-")[-2:]]
-            # append the frame file to the list
-            frame_list.append(FrameFile(ifos[i], frame_path, gps_start, duration))
+    url = find_urls(site, frametype, seg_start, seg_stop, host=host)
+    frame_paths = [fp.replace("file://localhost", "") for fp in url]
+
+    for frame_path in frame_paths:
+        # get the file name without the extension with pathlib
+        frame_name = Path(frame_path).stem
+        # get the gps time and duration with int type
+        gps_start, duration = [int(i) for i in frame_name.split("-")[-2:]]
+        # append the frame file to the list
+        frame_list.append(FrameFile(ifo, frame_path, gps_start, duration))
+
+    # TODO: check if the framefiles match with the seg_start and seg_stop
 
     return frame_list
 

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/job_segment/job_segment.py

@@ -1,11 +1,12 @@
 import logging
 
+import numpy as np
 import orjson
 
-from .super_lag import get_slag_job_list, get_slag_list
-from .dq_segment import read_seg_list, get_seg_list, get_job_list
+from .dq_segment import read_seg_list, get_job_list, merge_seg_list
 from .frame import get_frame_meta, select_frame_list, get_frame_files_from_gwdatafind
 from pycwb.types.job import WaveSegment
+from ..superlag import generate_slags
 from ...utils.module import import_helper
 from pycwb.modules.gracedb import get_superevent_t0
 
@@ -36,7 +37,11 @@ def create_job_segment_from_config(config):
     job_segments = None
     periods = None
 
+    ############################################
     ## generate job segments based on the configuration if the DQ files or periods are specified
+    ############################################
+
+    ## generate the period with given gps times or superevent id
     # case 1: gps_start and gps_end are specified
     if config.gps_start and config.gps_end:
         periods = ([config.gps_start], [config.gps_end])
@@ -53,34 +58,46 @@ def create_job_segment_from_config(config):
         gps_center = int(get_superevent_t0(config.superevent))
         periods = ([gps_center - config.time_left], [gps_center + config.time_right])
 
-    # create job segments
+    ## create job segments
     if config.dq_files or periods:
         # get the job segments from the DQ files
         job_segments = job_segment_from_dq(config.dq_files, config.ifo,
-                                          config.segLen, config.segMLS, config.segEdge, config.segOverlap,
-                                          config.rateANA, config.l_high, config.inRate,
-                                           periods=periods)
+                                           config.segLen, config.segMLS, config.segEdge, config.segOverlap,
+                                           config.rateANA, config.l_high, config.inRate, periods=periods,
+                                           slag_size=config.slagSize, slag_off=config.slagOff,
+                                           slag_min=config.slagMin, slag_max=config.slagMax)
+
+    ############################################
+    ## injections on job segments
+    ############################################
 
-    ## if only simulation mode is specified without DQ files or periods,
+    ## Case 1: if only simulation mode is specified without DQ files or periods,
     # create job segments based on the injection parameters
     if config.simulation and job_segments is None:
         # TODO: split out the injection part for other job types
         job_segments = create_job_segment_from_injection(config.ifo, config.simulation, config.injection,
                                                          config.inRate, config.segEdge)
 
-    ## TODO: when the DQ files and simulation both are specified, inject the parameters into the job segments
+    ## TODO: Case 2: when the DQ files and simulation both are specified, inject the parameters into the job segments
 
+    ############################################
+    ## Load the frames if frFiles or gwdatafind specified
+    ############################################
     # attach the frame files to the job segments if defined
     if config.frFiles:
+        # if frFiles exist, attach the given framefiles to the job segments
         attach_frame_files_to_job_segments(job_segments, config.ifo, config.frFiles, config.segEdge)
 
     if config.gwdatafind:
+        # if gwdatafind specified, use gwdatafind to fetch the frame files for each job segment
         gwdatafind_frames_for_job_segments(job_segments, config.ifo, config.gwdatafind, config.segEdge)
-    # attach the channel names to the job segments
+
+    # attach the channel names to the job segments from config for self-contained information
     if config.channelNamesRaw:
         for job_seg in job_segments:
             job_seg.channels = config.channelNamesRaw
 
+    ############################################
     ## TODO: check if the job segments are valid
     logger.info(f"Number of segments: {len(job_segments)}")
     logger.info("-" * 80)
@@ -127,34 +144,60 @@ def job_segment_from_dq(dq_file_list, ifos, seg_len, seg_mls, seg_edge, seg_over
     :return: The job segment.
     :rtype: WaveSegment
     """
+    # merge the DQ segments for each interferometer
+    seg_lists = []
+    for ifo in ifos:
+        dq_files = [dq_file for dq_file in dq_file_list if dq_file.ifo == ifo]
+        cat1_list = read_seg_list(dq_files, 'CWB_CAT1')
+        seg_lists.append(cat1_list)
+
+    # for zero super lag, merge the segments, and get the standard job segments
+    merged_seg_list = seg_lists[0]
+    for seg_list in seg_lists[1:]:
+        merged_seg_list = merge_seg_list(merged_seg_list, seg_list)
+
+    job_segments = []
+    # for super lag, shift the cat1 list and merge the segments
     if slag_size > 0:
-        # TODO: not finished
-        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1', periods)
-
-        # Get number/list of available super lag jobs
-        # Compute the available segments with length=segLen contained between the interval [min,max]
-        # Where min,max are the minimum and macimum times in the cat1List list
-        # The start time of each segment is forced to be a multiple of segLen
-        slag_job_list = get_slag_job_list(cat1_list, seg_len)
-
-        slag_segments = len(slag_job_list)
-
-        # Get super lag list : slagList
-        # Is the list of available segment shifts according to the slag configuration parameters
-        slag_list = get_slag_list(slag_segments, slag_size, slag_segments, slag_off, slag_min, slag_max, slag_site,
-                                  slag_file)
-
-        for slag in slag_list:
-            logger.info(f"SuperLag={slag.slag_id[0]} jobID={slag.job_id}")
-            for n in range(len(ifos)):
-                logger.info(f"segID[{slag.slag_id[1]}]={slag.seg_id[n]}")
-
-        raise Exception("Not finished")
-
+        # TODO: add checks on maximum super lag size
+        slags = generate_slags(len(ifos), slag_min, slag_max, slag_off, slag_size)
+
+        for slag in slags:
+            slag_seg_lists = []
+            for ifo, j in enumerate(slag):
+                slag_seg_lists.append(np.array(seg_lists[ifo]) + j * seg_len)
+
+            merged_slag_seg_list = slag_seg_lists[0]
+            for seg_list in slag_seg_lists[1:]:
+                merged_slag_seg_list = merge_seg_list(merged_slag_seg_list, seg_list)
+            print('live time', merged_slag_seg_list[1][0] - merged_slag_seg_list[0][0])
+            job_segments += get_job_list(ifos, merged_seg_list, seg_len, seg_mls,
+                                         seg_edge=seg_edge, sample_rate=sample_rate,
+                                         shift=np.array(slag) * seg_len, index_start=len(job_segments))
     else:
-        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1', periods)
-
-        job_segments = get_job_list(ifos, cat1_list, seg_len, seg_mls, seg_edge, sample_rate)
+        job_segments += get_job_list(ifos, merged_seg_list, seg_len, seg_mls, seg_edge, sample_rate)
+
+
+    # cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1', periods)
+        #
+        # # Get number/list of available super lag jobs
+        # # Compute the available segments with length=segLen contained between the interval [min,max]
+        # # Where min,max are the minimum and macimum times in the cat1List list
+        # # The start time of each segment is forced to be a multiple of segLen
+        # slag_job_list = get_slag_job_list(cat1_list, seg_len)
+        #
+        # slag_segments = len(slag_job_list)
+        #
+        # # Get super lag list : slagList
+        # # Is the list of available segment shifts according to the slag configuration parameters
+        # slag_list = get_slag_list(slag_segments, slag_size, slag_segments, slag_off, slag_min, slag_max, slag_site,
+        #                           slag_file)
+        #
+        # for slag in slag_list:
+        #     logger.info(f"SuperLag={slag.slag_id[0]} jobID={slag.job_id}")
+        #     for n in range(len(ifos)):
+        #         logger.info(f"segID[{slag.slag_id[1]}]={slag.seg_id[n]}")
+        # raise Exception("Not finished")
 
     rate_min = rateANA >> l_high
     for job_seg in job_segments:
@@ -178,14 +221,20 @@ def job_segment_from_dq(dq_file_list, ifos, seg_len, seg_mls, seg_edge, seg_over
 
 def attach_frame_files_to_job_segments(job_segments, ifos, fr_files, seg_edge):
     # Get frame file list
-    frame_files = []
-    for i in range(len(ifos)):
-        frame_files += get_frame_meta(fr_files[i], ifos[i])
+    frame_files = {}
+    for i, ifo in enumerate(ifos):
+        frame_files[ifo] = get_frame_meta(fr_files[i], ifo)
 
     # Select frame files for each job segment
-    # TODO: this is only for simple job segment
     for job_seg in job_segments:
-        job_seg.frames = select_frame_list(frame_files, job_seg.start_time, job_seg.end_time, seg_edge)
+        if job_seg.frames is None:
+            job_seg.frames = []
+        for ifo in ifos:
+            job_seg.frames += select_frame_list(frame_files[ifo],
+                                                job_seg.physical_start_times[ifo],
+                                                job_seg.physical_end_times[ifo],
+                                                seg_edge)
+        # job_seg.frames = select_frame_list(frame_files, job_seg.start_time, job_seg.end_time, seg_edge)
 
 
 def gwdatafind_frames_for_job_segments(job_segments, ifos, gwdatafind, seg_edge):
@@ -211,8 +260,15 @@ def gwdatafind_frames_for_job_segments(job_segments, ifos, gwdatafind, seg_edge)
     host = gwdatafind.get('host')
 
     for job_seg in job_segments:
-        job_seg.frames = get_frame_files_from_gwdatafind(ifos, gwdatafind['site'], gwdatafind['frametype'],
-                                                         job_seg.start_time, job_seg.end_time, seg_edge, host=host)
+        if job_seg.frames is None:
+            job_seg.frames = []
+        for i, ifo in enumerate(ifos):
+            job_seg.frames += get_frame_files_from_gwdatafind(ifo, gwdatafind['site'][i], gwdatafind['frametype'][i],
+                                                            job_seg.physical_start_times[ifo],
+                                                            job_seg.physical_end_times[ifo],
+                                                            seg_edge, host=host)
+        # job_seg.frames = get_frame_files_from_gwdatafind(ifos, gwdatafind['site'], gwdatafind['frametype'],
+        #                                                  job_seg.start_time, job_seg.end_time, seg_edge, host=host)
 
 
 def create_job_segment_from_injection(ifo, simulation_mode, injection, sample_rate, seg_edge):

{pycwb-0.24.0 → pycwb-0.25.0}/pycwb/modules/job_segment/module.yaml

@@ -1,4 +1,4 @@
 name: job_segment
 author: pycWB
 description: Job segment module
-dependencies: ["numpy", "matplotlib"]
+dependencies: ["numpy", "matplotlib", "@gracedb", "@superlag"]