def test_from_veto_def(self): from glue.ligolw.lsctables import VetoDef def veto_def(ifo, name, version, **kwargs): vdef = VetoDef() kwargs['ifo'] = ifo kwargs['name'] = name kwargs['version'] = version for key in VetoDef.__slots__: setattr(vdef, key, kwargs.get(key, None)) return vdef a = veto_def('X1', 'TEST-FLAG', 1, start_time=0, end_time=0, start_pad=-2, end_pad=2, comment='Comment') f = self.TEST_CLASS.from_veto_def(a) assert f.name == 'X1:TEST-FLAG:1' assert f.category is None assert f.padding == (-2, 2) assert f.description == 'Comment' utils.assert_segmentlist_equal(f.known, [(0, float('inf'))]) a = veto_def('X1', 'TEST-FLAG', None, start_time=0, end_time=1) f = self.TEST_CLASS.from_veto_def(a) assert f.name == 'X1:TEST-FLAG' assert f.version is None
def test_query_dqsegdb(self, name, flag): result = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, 0, 10) RESULT = QUERY_RESULTC[flag] assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active) result2 = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, (0, 10)) utils.assert_flag_equal(result, result2) result2 = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, SegmentList([(0, 10)])) utils.assert_flag_equal(result, result2) with pytest.raises(ValueError): query_dqsegdb(self.TEST_CLASS.query_dqsegdb, 'BAD-FLAG_NAME', SegmentList([(0, 10)])) with pytest.raises(HTTPError) as exc: query_dqsegdb(self.TEST_CLASS.query_dqsegdb, 'X1:GWPY-TEST:0', 0, 10) assert str(exc.value) == 'HTTP Error 404: Not found [X1:GWPY-TEST:0]' with pytest.raises(TypeError): self.TEST_CLASS.query_dqsegdb(QUERY_FLAGS[0], 1, 2, 3) with pytest.raises(TypeError): self.TEST_CLASS.query_dqsegdb(QUERY_FLAGS[0], (1, 2, 3))
def test_query_dqsegdb_multi(self): segs = SegmentList([Segment(0, 2), Segment(8, 10)]) result = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, QUERY_FLAGS[0], segs) RESULT = QUERY_RESULTC[QUERY_FLAGS[0]] assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known & segs) utils.assert_segmentlist_equal(result.active, RESULT.active & segs)
def test_known(self, empty, flag): assert isinstance(empty.known, SegmentList) assert empty.known == [] utils.assert_segmentlist_equal(flag.known, KNOWN) new = self.TEST_CLASS() new.known = [(1, 2), (3, 4)] assert isinstance(empty.known, SegmentList)
def test_active(self, empty, flag): assert isinstance(empty.active, SegmentList) assert empty.active == [] utils.assert_segmentlist_equal(flag.active, ACTIVE) new = self.TEST_CLASS() new.active = [(1, 2), (3, 4)] assert isinstance(empty.active, SegmentList)
def test_fetch_open_data(self): try: segs = self.TEST_CLASS.fetch_open_data( 'H1_DATA', 946339215, 946368015) except (URLError, SSLError) as exc: pytest.skip(str(e)) assert segs.ifo == 'H1' assert segs.name == 'H1:DATA' assert segs.label == 'H1_DATA' utils.assert_segmentlist_equal(segs.known, [(946339215, 946368015)]) utils.assert_segmentlist_equal(segs.active, [ (946340946, 946351799), (946356479, 946360619), (946362652, 946368015), ])
def test_read_write_segwizard(self, segmentlist): with tempfile.NamedTemporaryFile(suffix='.txt', mode='w') as f: # check write/read returns the same list segmentlist.write(f.name) sl2 = self.TEST_CLASS.read(f.name, coalesce=False) utils.assert_segmentlist_equal(sl2, segmentlist) assert isinstance(sl2[0][0], LIGOTimeGPS) # check that coalesceing does what its supposed to c = type(segmentlist)(segmentlist).coalesce() sl2 = self.TEST_CLASS.read(f.name, coalesce=True) utils.assert_segmentlist_equal(sl2, c) # check gpstype kwarg sl2 = self.TEST_CLASS.read(f.name, gpstype=float) assert isinstance(sl2[0][0], float)
def test_query_segdb(self): result = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], 0, 10) RESULT = QUERY_RESULT[QUERY_FLAGS[0]] assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active) result2 = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], (0, 10)) utils.assert_flag_equal(result, result2) result2 = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], SegmentList([(0, 10)])) utils.assert_flag_equal(result, result2)
def test_populate(self): def fake(): return self.TEST_CLASS({ x: self.ENTRY_CLASS(name=x, known=y.known) for x, y in QUERY_RESULT.items() }) # build fake veto definer file vdf = fake() vdf2 = fake() vdf3 = fake() flag = QUERY_FLAGS[0] vdf2[flag].padding = (-1, 1) span = SegmentList([Segment(0, 2)]) # and populate using a mocked query with mock.patch('dqsegdb.apicalls.dqsegdbQueryTimes', mocks.dqsegdb_query_times(QUERY_RESULT)): vdf.populate() vdf2.populate() vdf3.populate(segments=span) # test warnings on bad entries vdf['TEST'] = self.ENTRY_CLASS('X1:BLAHBLAHBLAH:1', known=[(0, 1)]) with pytest.warns(UserWarning) as record: vdf.populate(on_error='warn') vdf.populate(on_error='ignore') assert len(record) == 1 vdf.pop('TEST') with pytest.raises(ValueError): vdf.populate(on_error='blah') # check basic populate worked utils.assert_dict_equal(vdf, QUERY_RESULTC, utils.assert_flag_equal) # check padded populate worked utils.assert_flag_equal(vdf2[flag], QUERY_RESULTC[flag].pad(-1, 1)) # check segment-restricted populate worked for flag in vdf3: utils.assert_segmentlist_equal(vdf3[flag].known, QUERY_RESULTC[flag].known & span) utils.assert_segmentlist_equal(vdf3[flag].active, QUERY_RESULTC[flag].active & span)
def test_populate(self): def fake(): return self.TEST_CLASS({ x: self.ENTRY_CLASS(name=x, known=y.known) for x, y in QUERY_RESULT.items()}) # build fake veto definer file vdf = fake() vdf2 = fake() vdf3 = fake() flag = QUERY_FLAGS[0] vdf2[flag].padding = (-1, 1) span = SegmentList([Segment(0, 2)]) # and populate using a mocked query with mock.patch('dqsegdb.apicalls.dqsegdbQueryTimes', mocks.dqsegdb_query_times(QUERY_RESULT)): vdf.populate() vdf2.populate() vdf3.populate(segments=span) # test warnings on bad entries vdf['TEST'] = self.ENTRY_CLASS('X1:BLAHBLAHBLAH:1', known=[(0, 1)]) with pytest.warns(UserWarning) as record: vdf.populate(on_error='warn') vdf.populate(on_error='ignore') assert len(record) == 1 vdf.pop('TEST') with pytest.raises(ValueError): vdf.populate(on_error='blah') # check basic populate worked utils.assert_dict_equal(vdf, QUERY_RESULTC, utils.assert_flag_equal) # check padded populate worked utils.assert_flag_equal(vdf2[flag], QUERY_RESULTC[flag].pad(-1, 1)) # check segment-restricted populate worked for flag in vdf3: utils.assert_segmentlist_equal( vdf3[flag].known, QUERY_RESULTC[flag].known & span) utils.assert_segmentlist_equal( vdf3[flag].active, QUERY_RESULTC[flag].active & span)
def test_query(self, api): try: if api == 'dqsegdb': result = query_dqsegdb(self.TEST_CLASS.query, QUERY_FLAGS[0], 0, 10) RESULT = QUERY_RESULT[QUERY_FLAGS[0]].copy().coalesce() else: result = query_segdb(self.TEST_CLASS.query, QUERY_FLAGS[0], 0, 10, url='https://geosegdb.does.not.exist') RESULT = QUERY_RESULT[QUERY_FLAGS[0]] except ImportError as e: pytest.skip(str(e)) assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active)
def test_query_nds2_availability(self): # mock NDS2 query ndsb = mocks.nds2_buffer(self.NAMES[0], [], 0, 64, 'm') availability = [ mocks.nds2_availability(self.NAMES[0], [(0, 10), (20, 30)]), ] conn = mocks.nds2_connection(buffers=[ndsb]) conn.get_availability.return_value = availability with mock.patch('nds2.connection') as ndsc: ndsc.return_value = conn avail = self.TEST_CLASS.query_nds2_availability( [self.NAMES[0]], 0, 30, host='test') assert isinstance(avail, SegmentListDict) utils.assert_segmentlist_equal(avail[self.NAMES[0]], [(0, 10), (20, 30)])
def test_query(self, api): try: if api == 'dqsegdb': result = query_dqsegdb(self.TEST_CLASS.query, QUERY_FLAGS[0], 0, 10) RESULT = QUERY_RESULT[QUERY_FLAGS[0]].copy().coalesce() else: result = query_segdb(self.TEST_CLASS.query, QUERY_FLAGS[0], 0, 10, url='https://segdb.does.not.exist') RESULT = QUERY_RESULT[QUERY_FLAGS[0]] except ImportError as e: pytest.skip(str(e)) assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active)
def test_query_nds2_availability(self): # mock NDS2 query ndsb = mocks.nds2_buffer(self.NAMES[0], [], 0, 64, 'm') availability = [ mocks.nds2_availability(self.NAMES[0], [(0, 10), (20, 30)]), ] conn = mocks.nds2_connection(buffers=[ndsb]) conn.get_availability.return_value = availability with mock.patch('nds2.connection') as ndsc: ndsc.return_value = conn avail = self.TEST_CLASS.query_nds2_availability([self.NAMES[0]], 0, 30, host='test') assert isinstance(avail, SegmentListDict) utils.assert_segmentlist_equal(avail[self.NAMES[0]], [(0, 10), (20, 30)])
def test_query_segdb(self): result = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], 0, 10) RESULT = QUERY_RESULT[QUERY_FLAGS[0]] assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active) result2 = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], (0, 10)) utils.assert_flag_equal(result, result2) result2 = query_segdb(self.TEST_CLASS.query_segdb, QUERY_FLAGS[0], SegmentList([(0, 10)])) utils.assert_flag_equal(result, result2) with pytest.raises(TypeError): self.TEST_CLASS.query_segdb(QUERY_FLAGS[0], 1, 2, 3) with pytest.raises(TypeError): self.TEST_CLASS.query_segdb(QUERY_FLAGS[0], (1, 2, 3))
def test_read_write_hdf5(self, segmentlist, ext): tempdir = tempfile.mkdtemp() try: fp = tempfile.mktemp(suffix=ext, dir=tempdir) # check basic write/read with auto-path discovery segmentlist.write(fp, 'test-segmentlist') sl2 = self.TEST_CLASS.read(fp) utils.assert_segmentlist_equal(sl2, segmentlist) assert isinstance(sl2[0][0], LIGOTimeGPS) sl2 = self.TEST_CLASS.read(fp, path='test-segmentlist') utils.assert_segmentlist_equal(sl2, segmentlist) # check overwrite kwarg with pytest.raises(IOError): segmentlist.write(fp, 'test-segmentlist') segmentlist.write(fp, 'test-segmentlist', overwrite=True) # check gpstype kwarg sl2 = self.TEST_CLASS.read(fp, gpstype=float) utils.assert_segmentlist_equal(sl2, segmentlist) assert isinstance(sl2[0][0], float) finally: if os.path.isdir(tempdir): shutil.rmtree(tempdir)
def test_from_veto_definer_file(self, veto_definer): # read veto definer vdf = self.TEST_CLASS.from_veto_definer_file(veto_definer) assert len(vdf.keys()) == 4 # test one flag to make sure it is well read name = 'X1:TEST-FLAG:1' assert name in vdf utils.assert_segmentlist_equal(vdf[name].known, [(100, float('inf'))]) assert vdf[name].category is 1 assert vdf[name].padding == (-1, 2) # test ifo kwarg vdf = self.TEST_CLASS.from_veto_definer_file(veto_definer, ifo='X1') assert len(vdf.keys()) == 3 assert 'Y1:TEST-FLAG_2:2' not in vdf # test start and end kwargs vdf = self.TEST_CLASS.from_veto_definer_file(veto_definer, start=200, end=300) assert len(vdf.keys()) == 3 assert 'X1:TEST-FLAG_2:1' not in vdf
def test_query_dqsegdb(self, name, flag): result = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, 0, 10) RESULT = QUERY_RESULTC[flag] assert isinstance(result, self.TEST_CLASS) utils.assert_segmentlist_equal(result.known, RESULT.known) utils.assert_segmentlist_equal(result.active, RESULT.active) result2 = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, (0, 10)) utils.assert_flag_equal(result, result2) result2 = query_dqsegdb(self.TEST_CLASS.query_dqsegdb, name, SegmentList([(0, 10)])) utils.assert_flag_equal(result, result2) with pytest.raises(ValueError): query_dqsegdb(self.TEST_CLASS.query_dqsegdb, 'BAD-FLAG_NAME', SegmentList([(0, 10)])) with pytest.raises(HTTPError) as exc: query_dqsegdb(self.TEST_CLASS.query_dqsegdb, 'X1:GWPY-TEST:0', 0, 10) assert str(exc.value) == 'HTTP Error 404: Not found [X1:GWPY-TEST:0]'
def test_get_mp_cache_segments(): """Test `gwpy.timeseries.io.cache.get_mp_cache_segments` """ from lal.utils import CacheEntry from glue.lal import Cache from glue.segmentsUtils import segmentlist_range Cache.entry_class = CacheEntry # make cache cache = Cache() segments = SegmentList([Segment(0, 10), Segment(20, 30)]) fsegs = SegmentList([s for seg in segments for s in segmentlist_range(seg[0], seg[1], 2)]) cache = Cache([CacheEntry.from_T050017( 'A-B-{0}-{1}.ext'.format(s[0], abs(s))) for s in fsegs]) # assert that no multiprocessing just returns the segment assert_segmentlist_equal( tio_cache.get_mp_cache_segments(cache, 1, Segment(0, 30)), SegmentList([Segment(0, 30)])) # simple test that segments get divided as expected mpsegs = tio_cache.get_mp_cache_segments(cache, 2, Segment(0, 30)) assert_segmentlist_equal(mpsegs, segments) # test that mismatch with files edges is fine mpsegs = tio_cache.get_mp_cache_segments(cache, 2, Segment(0, 21)) assert not mpsegs - SegmentList([Segment(0, 21)]) # test segment divisions mpsegs = tio_cache.get_mp_cache_segments(cache, 4, Segment(0, 30)) assert_segmentlist_equal( mpsegs, SegmentList(map(Segment, [(0, 6), (6, 10), (20, 26), (26, 30)])) )
def test_protract(self): flag = self.create(active=ACTIVE_CONTRACTED) flag.protract(.1) utils.assert_segmentlist_equal(flag.known, KNOWN) utils.assert_segmentlist_equal(flag.active, ACTIVE)
def test_coalesce(self): segmentlist = self.create((1, 2), (3, 4), (4, 5)) c = segmentlist.coalesce() assert c is segmentlist utils.assert_segmentlist_equal(c, [(1, 2), (3, 5)]) assert isinstance(c[0], self.ENTRY_CLASS)
def test_pad(self, flag): # test with no arguments (and no padding) padded = flag.pad() utils.assert_flag_equal(flag, padded) # test with padding flag.padding = PADDING padded = flag.pad() utils.assert_segmentlist_equal(padded.known, KNOWNPAD) utils.assert_segmentlist_equal(padded.active, ACTIVEPAD) # test with arguments flag.padding = None padded = flag.pad(*PADDING) utils.assert_segmentlist_equal(padded.known, KNOWNPAD) utils.assert_segmentlist_equal(padded.active, ACTIVEPAD) # test in-place padded = flag.pad(*PADDING) assert padded is not flag padded = flag.pad(*PADDING, inplace=True) assert padded is flag utils.assert_segmentlist_equal(flag.known, KNOWNPAD) utils.assert_segmentlist_equal(flag.active, ACTIVEPAD) # check that other keyword arguments get rejected appropriately with pytest.raises(TypeError): flag.pad(*PADDING, kwarg='test')
def test_math(self): a = self.TEST_CLASS(active=ACTIVE[:2], known=KNOWN) b = self.TEST_CLASS(active=ACTIVE[2:], known=KNOWN) # and x = a & b utils.assert_segmentlist_equal(x.active, []) utils.assert_segmentlist_equal(x.known, KNOWN) # sub x = a - b utils.assert_segmentlist_equal(x.active, a.active) # no overlap utils.assert_segmentlist_equal(x.known, a.known) # or x = a | b utils.assert_segmentlist_equal(x.active, ACTIVE) utils.assert_segmentlist_equal(x.known, KNOWN) # invert x = ~a utils.assert_segmentlist_equal(x.active, ~a.active) utils.assert_segmentlist_equal(x.known, ~a.known)
def test_intersection(self, instance): intersection = instance.intersection() assert isinstance(intersection, self.ENTRY_CLASS) utils.assert_segmentlist_equal(intersection.known, KNOWN & KNOWN2) utils.assert_segmentlist_equal(intersection.active, ACTIVE & ACTIVE2)
def test_union(self, instance): union = instance.union() assert isinstance(union, self.ENTRY_CLASS) utils.assert_segmentlist_equal(union.known, KNOWN + KNOWN2) utils.assert_segmentlist_equal(union.active, ACTIVE + ACTIVE2)
def test_math(self): a = self.TEST_CLASS(active=ACTIVE[:2], known=KNOWN) b = self.TEST_CLASS(active=ACTIVE[2:], known=KNOWN) # and x = a & b utils.assert_segmentlist_equal(x.active, a.active & b.active) utils.assert_segmentlist_equal(x.known, a.known & b.known) # sub x = a - b utils.assert_segmentlist_equal(x.active, a.active - b.active) utils.assert_segmentlist_equal(x.known, a.known & b.known) # or x = a | b utils.assert_segmentlist_equal(x.active, a.active | b.active) utils.assert_segmentlist_equal(x.known, a.known | b.known) # invert x = ~a utils.assert_segmentlist_equal(x.active, a.known & ~a.active) utils.assert_segmentlist_equal(x.known, a.known)
def test_coalesce(self): flag = self.create() flag.coalesce() utils.assert_segmentlist_equal(flag.known, KNOWN) utils.assert_segmentlist_equal(flag.active, KNOWNACTIVE) assert flag.regular is True
def test_round(self): flag = self.create(active=ACTIVE_CONTRACTED) r = flag.round() utils.assert_segmentlist_equal(r.known, KNOWN) utils.assert_segmentlist_equal(r.active, KNOWNACTIVE)