def _test_frame_read_format(self, format):
# test with specific format
try:
self.frame_read(format=format)
except ImportError as e:
self.skipTest(str(e))
else:
# test again with no format argument
# but we need to move other readers out of the way first
try:
read_ = get_reader('gwf', TimeSeries)
except Exception:
pass
else:
register_reader(
'gwf',
TimeSeries,
get_reader(format, TimeSeries),
force=True)
try:
self.frame_read()
finally:
register_reader('gwf', TimeSeries, read_, force=True)
# test errors
self.assertRaises(
ValueError,
self.TEST_CLASS.read,
Cache(),
self.channel,
format=format)
def test_inherited_registration():
# check that multi-generation inheritance works properly,
# meaning that a child inherits from parents before
# grandparents, see astropy/astropy#7156
class Child1(Table):
pass
class Child2(Child1):
pass
def _read():
return Table()
def _read1():
return Child1()
# check that reader gets inherited
io_registry.register_reader('test', Table, _read)
assert io_registry.get_reader('test', Child2) is _read
# check that nearest ancestor is identified
# (i.e. that the reader for Child2 is the registered method
# for Child1, and not Table)
io_registry.register_reader('test', Child1, _read1)
assert io_registry.get_reader('test', Child2) is _read1
def test_inherited_registration():
# check that multi-generation inheritance works properly,
# meaning that a child inherits from parents before
# grandparents, see astropy/astropy#7156
class Child1(Table):
pass
class Child2(Child1):
pass
def _read():
return Table()
def _read1():
return Child1()
# check that reader gets inherited
io_registry.register_reader('test', Table, _read)
assert io_registry.get_reader('test', Child2) is _read
# check that nearest ancestor is identified
# (i.e. that the reader for Child2 is the registered method
# for Child1, and not Table)
io_registry.register_reader('test', Child1, _read1)
assert io_registry.get_reader('test', Child2) is _read1
def _test_frame_read_format(self, format):
# test with specific format
try:
self.frame_read(format=format)
except ImportError as e:
self.skipTest(str(e))
else:
# test again with no format argument
# but we need to move other readers out of the way first
try:
read_ = get_reader('gwf', TimeSeries)
except Exception:
pass
else:
register_reader('gwf',
TimeSeries,
get_reader(format, TimeSeries),
force=True)
try:
self.frame_read()
finally:
register_reader('gwf', TimeSeries, read_, force=True)
# test empty Cache()
self.assertRaises(ValueError,
self.TEST_CLASS.read,
Cache(),
self.channel,
format=format)
# test cache method with `nproc=2`
c = Cache.from_urls([TEST_GWF_FILE])
ts = self.TEST_CLASS.read(c, self.channel, nproc=2, format=format)
def inherit_io_registrations(cls):
parent = cls.__mro__[1]
for row in registry.get_formats(data_class=parent):
name = row["Format"]
# read
if row["Read"].lower() == "yes":
registry.register_reader(
name,
cls,
registry.get_reader(name, parent),
force=False,
)
# write
if row["Write"].lower() == "yes":
registry.register_writer(
name,
cls,
registry.get_writer(name, parent),
force=False,
)
# identify
if row["Auto-identify"].lower() == "yes":
registry.register_identifier(
name,
cls,
registry._identifiers[(name, parent)],
force=False,
)
return cls
def decorate_registered_reader(
name,
data_class=EventTable,
columns=True,
selection=True,
):
"""Wrap an existing registered reader to use GWpy's input decorators
Parameters
----------
name : `str`
the name of the registered format
data_class : `type`, optional
the class for whom the format is registered
columns : `bool`, optional
use the `read_with_columns` decorator
selection : `bool`, optional
use the `read_with_selection` decorator
"""
reader = registry.get_reader(name, data_class)
wrapped = (
read_with_columns( # use ``columns``
read_with_selection( # use ``selection``
reader), ))
return registry.register_reader(name, data_class, wrapped, force=True)
def decorate_registered_reader(
name,
data_class=EventTable,
columns=True,
selection=True,
):
"""Wrap an existing registered reader to use GWpy's input decorators
Parameters
----------
name : `str`
the name of the registered format
data_class : `type`, optional
the class for whom the format is registered
columns : `bool`, optional
use the `read_with_columns` decorator
selection : `bool`, optional
use the `read_with_selection` decorator
"""
reader = registry.get_reader(name, data_class)
wrapped = ( # noqa
read_with_columns( # use ``columns``
read_with_selection( # use ``selection``
reader
))
)
return registry.register_reader(name, data_class, wrapped, force=True)
def _create_loader_filters(self):
# Create a dictionary mapping the registry loader names to the
# qt-specified loader names
def compose_filter_string(reader):
"""
Generates the Qt loader string to pass to the file load dialog.
"""
return ' '.join(['*.{}'.format(y) for y in reader.extensions]
if reader.extensions is not None else '*')
loader_name_map = {
'{} ({})'.format(
x['Format'], compose_filter_string(
get_reader(x['Format'], SpectrumList))): x['Format']
for x in io_registry.get_formats(SpectrumList) if x['Read'] == 'Yes'}
# Include an auto load function that lets the io machinery find the
# most appropriate loader to use
auto_filter = 'Auto (*)'
loader_name_map[auto_filter] = None
filters = list(loader_name_map.keys())
# Make sure that the "Auto (*)" loader shows up first. Being a bit
# pedantic about this even though we can probably just rely on
# dictionary ordering here.
index = filters.index(auto_filter)
filters.insert(0, filters.pop(index))
return filters, loader_name_map
def inherit_table_io(cls):
"""Inherit file I/O registrations from `~astropy.table.Table`
This decorator is modeled on `~gwpy.table.inherit_io_registrations`,
authored by Duncan Macleod, for more see https://gwpy.github.io
"""
for row in registry.get_formats(data_class=Table):
name = row["Format"]
# read
if row["Read"].lower() == "yes":
registry.register_reader(
name,
cls,
registry.get_reader(name, Table),
force=False,
)
# write
if row["Write"].lower() == "yes":
registry.register_writer(
name,
cls,
registry.get_writer(name, Table),
force=False,
)
# identify
if row["Auto-identify"].lower() == "yes":
registry.register_identifier(
name,
cls,
registry._identifiers[(name, Table)],
force=False,
)
return cls
def _create_loader_filters(self):
# Create a dictionary mapping the registry loader names to the
# qt-specified loader names
def compose_filter_string(reader):
"""
Generates the Qt loader string to pass to the file load dialog.
"""
return ' '.join(['*.{}'.format(y)
for y in reader.extensions] if reader.
extensions is not None else '*')
loader_name_map = {
'{} ({})'.format(
x['Format'],
compose_filter_string(get_reader(x['Format'], SpectrumList))):
x['Format']
for x in io_registry.get_formats(SpectrumList)
if x['Read'] == 'Yes'
}
# Include an auto load function that lets the io machinery find the
# most appropriate loader to use
auto_filter = 'Auto (*)'
loader_name_map[auto_filter] = None
filters = list(loader_name_map.keys())
# Make sure that the "Auto (*)" loader shows up first. Being a bit
# pedantic about this even though we can probably just rely on
# dictionary ordering here.
index = filters.index(auto_filter)
filters.insert(0, filters.pop(index))
return filters, loader_name_map
def inherit_io_registrations(cls):
parent = cls.__mro__[1]
for row in registry.get_formats(data_class=parent):
name = row["Format"]
# read
if row["Read"].lower() == "yes":
registry.register_reader(
name,
cls,
registry.get_reader(name, parent),
force=False,
)
# write
if row["Write"].lower() == "yes":
registry.register_writer(
name,
cls,
registry.get_writer(name, parent),
force=False,
)
# identify
if row["Auto-identify"].lower() == "yes":
registry.register_identifier(
name,
cls,
registry._identifiers[(name, parent)],
force=False,
)
return cls
def __init__(self, name, start, end, channel=None, etg=None, table=None,
cache=None, url=None, **kwargs):
"""Create a new `EventTriggerTab`
"""
super(EventTriggerTab, self).__init__(name, start, end, **kwargs)
self.channel = channel and get_channel(channel) or None
self.cache = cache
self.url = url
self.error = dict()
# parse ETG and LIGO_LW table class
if etg is None:
etg = self.name
self.etg = etg
if table is None or isinstance(table, str):
tablename = isinstance(table, str) and table or self.etg
try:
table = get_etg_table(tablename)
except KeyError as e:
e.args = ("Cannot automatically determine LIGO_LW table for "
"etg %r, please specify in configuration file or "
"when creating EventTriggerTab" % tablename,)
raise
# register custom readers for this type
try:
register_etg_table(self.etg.lower(), table)
except KeyError:
pass
try:
register_reader(self.etg.lower(), table,
get_reader('ligolw', table))
except Exception as e:
if 'already defined' in str(e):
pass
else:
raise
def read_file(self, file_name, file_filter):
"""
Convenience method that directly reads a spectrum from a file.
Parameters
----------
file_name: str
Name of the file to read.
file_filter: str
Type of file to read. If `Auto`, try all known formats.
Returns
-------
data: Spectrum1DRef
The file's data or None if no known formats are found.
Notes
-----
This exists mostly to facilitate development workflow. In time it
could be augmented to support fancier features such as wildcards,
file lists, mixed file types, and the like.
Note that the filter string is hard coded here; its details might
depend on the intrincacies of the registries, loaders, and data
classes. In other words, this is brittle code.
"""
file_filter = 'Auto (*)' if file_filter is None else file_filter
logging.info("Attempting to read file {} with {}.".format(
file_name, file_filter))
if not (file_name and file_filter):
return
file_name = str(file_name)
file_ext = os.path.splitext(file_name)[-1]
all_formats = io_registry.get_formats(Spectrum1DRef)['Format']
if file_filter == 'Auto (*)':
#-- sort loaders by priorty given in the definition
all_priority = [
getattr(io_registry.get_reader(fmt, Spectrum1DRef), 'priority',
0) for fmt in all_formats
]
all_registry = sorted(zip(all_formats, all_priority),
key=lambda item: item[1],
reverse=True)
all_formats = [item[0] for item in all_registry]
else:
all_formats = [x for x in all_formats if file_filter in x]
for format in all_formats:
logging.info("Trying to load with {}".format(format))
try:
data = Spectrum1DRef.read(file_name, format=format)
return data
except Exception as e:
logging.error("Incompatible loader for selected data: {"
"} because {}".format(file_filter, e))
def _on_load_data(self):
"""
When the user loads a data file, this method is triggered. It provides
a file open dialog and from the dialog attempts to create a new
:class:`~specutils.SpectrumList` object and thereafter adds the
contents to the data model.
"""
# Create a dictionary mapping the registry loader names to the
# qt-specified loader names
def compose_filter_string(reader):
return ' '.join(['*.{}'.format(y)
for y in reader.extensions] if reader.
extensions is not None else '*')
loader_name_map = {
'{} ({})'.format(
x['Format'],
compose_filter_string(get_reader(x['Format'], SpectrumList))):
x['Format']
for x in io_registry.get_formats(SpectrumList)
if x['Read'] == 'Yes'
}
# Include an auto load function that lets the io machinery find the
# most appropriate loader to use
loader_name_map['Auto (*)'] = None
# This ensures that users actively have to select a file type before
# being able to select a file. This should make it harder to
# accidentally load a file using the wrong type, which results in weird
# errors.
filters = ['Select loader...'] + list(loader_name_map.keys())
file_path, fmt = compat.getopenfilename(
parent=self,
basedir=os.getcwd(),
caption="Load spectral data file",
filters=";;".join(filters))
if not file_path:
return
self.load_data(file_path, file_loader=loader_name_map[fmt])
def __init__(self,
name,
start,
end,
channel=None,
etg=None,
table=None,
cache=None,
url=None,
**kwargs):
"""Create a new `EventTriggerTab`
"""
super(EventTriggerTab, self).__init__(name, start, end, **kwargs)
self.channel = channel and get_channel(channel) or None
self.cache = cache
self.url = url
self.error = dict()
# parse ETG and LIGO_LW table class
if etg is None:
etg = self.name
self.etg = etg
if table is None or isinstance(table, str):
tablename = isinstance(table, str) and table or self.etg
try:
table = get_etg_table(tablename)
except KeyError as e:
e.args = ("Cannot automatically determine LIGO_LW table for "
"etg %r, please specify in configuration file or "
"when creating EventTriggerTab" % tablename, )
raise
# register custom readers for this type
try:
register_etg_table(self.etg.lower(), table)
except KeyError:
pass
try:
register_reader(self.etg.lower(), table,
get_reader('ligolw', table))
except Exception as e:
if 'already defined' in str(e):
pass
else:
raise
def test_register_reader():
io_registry.register_reader('test1', TestData, empty_reader)
io_registry.register_reader('test2', TestData, empty_reader)
assert io_registry.get_reader('test1', TestData) == empty_reader
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test1', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test1', TestData)
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test2', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test2', TestData)
def test_register_reader():
io_registry.register_reader('test1', TestData, empty_reader)
io_registry.register_reader('test2', TestData, empty_reader)
assert io_registry.get_reader('test1', TestData) == empty_reader
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test1', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test1', TestData)
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test2', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test2', TestData)
def register_library_format(container, library):
"""Register methods for the given library format
E.g. for lalframe this functions creates methods and registers them
for the ``lalframe`` format name.
This format has been deprecated and will be removed prior to the 1.0
release in favour of the ``gwf.<library>`` contention. All this method
does is create directes from `format='<library'` to
`format=gwf.<library>'`.
Parameters
----------
container : `Series`, `dict`
series class or series dict class to register
library : `str`
name of frame library
"""
fmt = 'gwf.%s' % library
reader = get_reader(fmt, container)
writer = get_writer(fmt, container)
def read_(*args, **kwargs):
warnings.warn("Reading with format=%r is deprecated and will be "
"disabled in an upcoming release, please use "
"format=%r instead" % (library, fmt),
DeprecationWarning)
return reader(*args, **kwargs)
def write_(*args, **kwargs):
warnings.warn("Writing with format=%r is deprecated and will be "
"disabled in an upcoming release, please use "
"format=%r instead" % (library, fmt),
DeprecationWarning)
return writer(*args, **kwargs)
register_reader(library, container, read_)
register_writer(library, container, write_)
def register_library_format(container, library):
"""Register methods for the given library format
E.g. for lalframe this functions creates methods and registers them
for the ``lalframe`` format name.
This format has been deprecated and will be removed prior to the 1.0
release in favour of the ``gwf.<library>`` contention. All this method
does is create directes from `format='<library'` to
`format=gwf.<library>'`.
Parameters
----------
container : `Series`, `dict`
series class or series dict class to register
library : `str`
name of frame library
"""
fmt = 'gwf.%s' % library
reader = get_reader(fmt, container)
writer = get_writer(fmt, container)
def read_(*args, **kwargs):
warnings.warn(
"Reading with format=%r is deprecated and will be "
"disabled in an upcoming release, please use "
"format=%r instead" % (library, fmt), DeprecationWarning)
return reader(*args, **kwargs)
def write_(*args, **kwargs):
warnings.warn(
"Writing with format=%r is deprecated and will be "
"disabled in an upcoming release, please use "
"format=%r instead" % (library, fmt), DeprecationWarning)
return writer(*args, **kwargs)
register_reader(library, container, read_)
register_writer(library, container, write_)
def test_get_reader_invalid():
with pytest.raises(io_registry.IORegistryError) as exc:
io_registry.get_reader('test', TestData)
assert str(exc.value).startswith(
"No reader defined for format 'test' and class 'TestData'")
def test_get_reader_invalid():
with pytest.raises(io_registry.IORegistryError) as exc:
io_registry.get_reader('test', TestData)
assert str(exc.value).startswith(
"No reader defined for format 'test' and class 'TestData'")
def __init__(self, *args, **kwargs):
super(DailyAhopeTab, self).__init__(*args, **kwargs)
register_etg_table(self.name.lower(), SnglInspiralTable)
register_reader(self.name.lower(), SnglInspiralTable,
get_reader('ligolw', SnglInspiralTable))
page.add(str(html.data_table(headers, data, table='data')))
if self.subplots:
page.hr(class_='row-divider')
page.h1('Sub-plots')
layout = get_mode() == MODE_ENUM['WEEK'] and [7] or [4]
plist = [p for p in self.subplots if p.state in [state, None]]
page.add(str(self.scaffold_plots(plots=plist, state=state,
layout=layout)))
# link full results
page.hr(class_='row-divider')
page.div(class_='btn-group')
page.a('Click here for the full Daily Ahope results',
href=self.ihopepage, rel='external', target='_blank',
class_='btn btn-default btn-info btn-xl')
page.div.close()
page.hr(class_='row-divider')
# write to file
idx = self.states.index(state)
with open(self.frames[idx], 'w') as fobj:
fobj.write(str(page))
return self.frames[idx]
register_tab(DailyAhopeTab)
register_tab(DailyAhopeTab, name='archived-daily-ihope')
register_reader('daily ahope', SnglInspiralTable,
get_reader('ligolw', SnglInspiralTable))
def __init__(self, *args, **kwargs):
super(DailyAhopeTab, self).__init__(*args, **kwargs)
register_etg_table(self.name.lower(), SnglInspiralTable)
register_reader(self.name.lower(), SnglInspiralTable,
get_reader('ligolw', SnglInspiralTable))
def read_(*args, **kwargs):
fmt = 'gwf.{}'.format(get_default_gwf_api())
reader = get_reader(fmt, container)
return reader(*args, **kwargs)
def read_(*args, **kwargs):
fmt = 'gwf.{}'.format(get_default_gwf_api())
reader = get_reader(fmt, container)
return reader(*args, **kwargs)
plist = [p for p in self.subplots if p.state in [state, None]]
page.add(
str(
self.scaffold_plots(plots=plist,
state=state,
layout=layout)))
# link full results
page.hr(class_='row-divider')
page.div(class_='btn-group')
page.a('Click here for the full Daily Ahope results',
href=self.ihopepage,
rel='external',
target='_blank',
class_='btn btn-default btn-info btn-xl')
page.div.close()
page.hr(class_='row-divider')
# write to file
idx = self.states.index(state)
with open(self.frames[idx], 'w') as fobj:
fobj.write(str(page))
return self.frames[idx]
register_tab(DailyAhopeTab)
register_tab(DailyAhopeTab, name='archived-daily-ihope')
register_reader('daily ahope', SnglInspiralTable,
get_reader('ligolw', SnglInspiralTable))
