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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)
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_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)
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_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)
