def vaex_reader(source):
"""
Read a vaex hdf5 file
"""
if os.path.isdir(source):
arrays = {}
for filename in glob.glob(os.path.join(source, '*')):
if is_vaex_file(filename):
logger.info("Reading vaex data from {0}".format(filename))
ds = vaex.open(filename)
else:
logger.info("Not a vaex file: {0}".format(filename))
# If there are no vaex files, we raise an error, and if there is one
# then we are done!
if len(arrays) == 0:
raise Exception(
"No vaex files found in directory: {0}".format(source))
elif len(arrays) == 1:
label = list(arrays.keys())[0]
return [Data(array=arrays[label], label=label)]
# We now check whether all the shapes of the vaex files are the same,
# and if so, we merge them into a single file.
labels = sorted(arrays)
ref_shape = arrays[labels[0]].shape
for label in labels[1:]:
if arrays[label].shape != ref_shape:
break
else:
# Since we are here, the shapes of all the vaex files match, so
# we can construct a higher-dimensional array.
# Make sure arrays are sorted while constructing array
array = np.array([arrays[label] for label in labels])
# We flip the array here on that in most cases we expect that the
# scan will start at the top of e.g. the body and move downwards.
array = array[::-1]
return [Data(array=array, label=dicom_label(source))]
# If we are here, the shapes of the vaex files didn't match, so we
# simply return one Data object per vaex file.
return [Data(array=arrays[label], label=label) for label in labels]
else:
ds = vaex.open(source)
data = [DataVaex(ds)]
return data
def main(argv=sys.argv):
opt, args = parse(argv[1:])
if opt.verbose:
logger.setLevel("INFO")
logger.info("Input arguments: %s", sys.argv)
# Global keywords for Glue startup.
kwargs = {'config': opt.config, 'maximized': not opt.nofs}
if opt.test:
return run_tests()
elif opt.restore:
start_glue(gluefile=args[0], **kwargs)
elif opt.script:
execute_script(args[0])
else:
has_file = len(args) == 1
has_files = len(args) > 1
has_py = has_file and args[0].endswith('.py')
has_glu = has_file and args[0].endswith('.glu')
if has_py:
execute_script(args[0])
elif has_glu:
start_glue(gluefile=args[0], **kwargs)
elif has_file or has_files:
start_glue(datafiles=args, **kwargs)
else:
start_glue(**kwargs)
def main(argv=sys.argv):
opt, args = parse(argv[1:])
if opt.verbose:
logger.setLevel("INFO")
logger.info("Input arguments: %s", sys.argv)
if opt.test:
return run_tests()
elif opt.restore:
start_glue(gluefile=args[0], config=opt.config)
elif opt.script:
execute_script(args[0])
else:
has_file = len(args) == 1
has_files = len(args) > 1
has_py = has_file and args[0].endswith('.py')
has_glu = has_file and args[0].endswith('.glu')
if has_py:
execute_script(args[0])
elif has_glu:
start_glue(gluefile=args[0], config=opt.config)
elif has_file or has_files:
start_glue(datafiles=args, config=opt.config)
else:
start_glue(config=opt.config)
def main(argv=sys.argv):
opt, args = parse(argv[1:])
if opt.verbose:
logger.setLevel("INFO")
logger.info("Input arguments: %s", sys.argv)
if opt.test:
return run_tests()
elif opt.restore:
start_glue(gluefile=args[0], config=opt.config)
elif opt.script:
execute_script(args[0])
else:
has_file = len(args) == 1
has_files = len(args) > 1
has_py = has_file and args[0].endswith('.py')
has_glu = has_file and args[0].endswith('.glu')
if has_py:
execute_script(args[0])
elif has_glu:
start_glue(gluefile=args[0], config=opt.config)
elif has_file or has_files:
start_glue(datafiles=args, config=opt.config)
else:
start_glue(config=opt.config)
def main(argv=sys.argv):
opt, args = parse(argv[1:])
if opt.verbose:
logger.setLevel("INFO")
logger.info("Input arguments: %s", sys.argv)
# Global keywords for Glue startup.
kwargs = {'config': opt.config,
'maximized': not opt.nomax}
if opt.test:
return run_tests()
elif opt.restore:
start_glue(gluefile=args[0], **kwargs)
elif opt.script:
execute_script(args[0])
else:
has_file = len(args) == 1
has_files = len(args) > 1
has_py = has_file and args[0].endswith('.py')
has_glu = has_file and args[0].endswith('.glu')
if has_py:
execute_script(args[0])
elif has_glu:
start_glue(gluefile=args[0], **kwargs)
elif has_file or has_files:
start_glue(datafiles=args, **kwargs)
else:
start_glue(**kwargs)
def default_members(self):
defaults = {}
for viewer in qt_client.members:
try:
defaults[viewer] = viewer._get_default_tools()
except AttributeError:
logger.info("could not get default tools for {0}".format(viewer.__name__))
defaults[viewer] = []
return defaults
def default_members(self):
defaults = {}
for viewer in qt_client.members:
try:
defaults[viewer] = viewer._get_default_tools()
except AttributeError:
logger.info("could not get default tools for {0}".format(viewer.__name__))
defaults[viewer] = []
return defaults
def __get__(self, instance, type=None):
# Under certain circumstances, PyQt will try and access these properties
# while loading the ui file, so we have to be robust to failures.
# However, we print out a warning if things fail.
try:
widget = reduce(getattr, [instance] + self._att)
return self.getter(widget)
except Exception:
logger.info("An error occured when accessing attribute {0} of {1}. Returning None.".format('.'.join(self._att), instance))
return None
def __get__(self, instance, type=None):
# Under certain circumstances, PyQt will try and access these properties
# while loading the ui file, so we have to be robust to failures.
# However, we print out a warning if things fail.
try:
widget = reduce(getattr, [instance] + self._att)
return self.getter(widget)
except Exception:
logger.info("An error occured when accessing attribute {0} of {1}. Returning None.".format('.'.join(self._att), instance))
return None
def setup():
from glue.logger import logger
from glue.config import tool_registry
from glue.viewers.image.qt import ImageWidget
from .contour_selection import ContourSelectionTool
tool_registry.add(ContourSelectionTool, widget_cls=ImageWidget)
logger.info("Loaded VizieR importer plugin")
def find_factory(filename, **kwargs):
from glue.config import data_factory
# We no longer try the 'default' factory first because we actually need to
# try all identifiers and select the one to use based on the priority. This
# allows us to define more specialized loaders take priority over more
# general ones. For example, a FITS file that is a dendrogram should be
# loaded as a dendrogram, not a plain FITS file.
best_priority = None
valid_formats = []
# Iterating over the data factory returns the formats sorted by decreasing
# alphabetical order then by label (alphabetically) in order to be
# deterministic. This is implemented in DataFactoryRegistry.__iter__.
for df in data_factory:
logger.info('Trying data factory {0}'.format(df.label))
# Once we've found a match, and iterated through the rest of the
# importers with the same priority, we can exit the loop.
if best_priority is not None and df.priority < best_priority:
break
if df.function is auto_data:
continue
try:
is_format = df.identifier(filename, **kwargs)
except ImportError: # dependencies missing
continue
except Exception: # any other issue
continue
if is_format:
valid_formats.append(df)
best_priority = df.priority
logger.info('Valid formats: {0}'.format(valid_formats))
if len(valid_formats) == 0:
return None
elif len(valid_formats) > 1:
labels = ["'{0}'".format(x.label) for x in valid_formats]
warnings.warn(
"Multiple data factories matched the input: {0}. Choosing {1}.".
format(', '.join(labels), labels[0]))
func = valid_formats[0].function
return func
def setup():
from .qt_widget import QtVizierImporter
from glue.config import importer
@importer("Import from VizieR")
def vizier_importer():
wi = QtVizierImporter()
wi.exec_()
return wi.datasets
from glue.logger import logger
logger.info("Loaded VizieR importer plugin")
def find_factory(filename, **kwargs):
from glue.config import data_factory
# We no longer try the 'default' factory first because we actually need to
# try all identifiers and select the one to use based on the priority. This
# allows us to define more specialized loaders take priority over more
# general ones. For example, a FITS file that is a dendrogram should be
# loaded as a dendrogram, not a plain FITS file.
best_priority = None
valid_formats = []
# Iterating over the data factory returns the formats sorted by decreasing
# alphabetical order then by label (alphabetically) in order to be
# deterministic. This is implemented in DataFactoryRegistry.__iter__.
for df in data_factory:
logger.info('Trying data factory {0}'.format(df.label))
# Once we've found a match, and iterated through the rest of the
# importers with the same priority, we can exit the loop.
if best_priority is not None and df.priority < best_priority:
break
if df.function is auto_data:
continue
try:
is_format = df.identifier(filename, **kwargs)
except ImportError: # dependencies missing
continue
except Exception: # any other issue
continue
if is_format:
valid_formats.append(df)
best_priority = df.priority
logger.info('Valid formats: {0}'.format(valid_formats))
if len(valid_formats) == 0:
return None
elif len(valid_formats) > 1:
labels = ["'{0}'".format(x.label) for x in valid_formats]
warnings.warn("Multiple data factories matched the input: {0}. Choosing {1}.".format(', '.join(labels), labels[0]))
func = valid_formats[0].function
return func
def set_mode(self, init=False):
log.info("Setting mode={0} with init={1}".format(self.mode, init))
# do not allow THIS to override "official" toolbar modes: we handle
# those correctly already
overwriteable_modes = ('line_panzoom', 'line_identify',
'line_select', 'cont_keyboard',
'cont_panzoom', 'cont_select',
'cont_exclude', 'line_keyboard', '')
if self.mode.startswith('line'):
if init:
log.info("Activating fitter")
self.spectrum.specfit.clear_all_connections()
self.spectrum.plotter.activate_interactive_fitter()
assert self.spectrum.plotter._active_gui is not None
self.spectrum.specfit.debug = self.spectrum.specfit._debug = True
elif self.mode.startswith('cont'):
if init:
log.info("Activating continuum fitter")
self.spectrum.baseline.clear_all_connections()
self.spectrum.plotter.activate_interactive_baseline_fitter(reset_selection=True)
assert self.spectrum.plotter._active_gui is not None
self.spectrum.baseline.debug = self.spectrum.baseline._debug = True
else:
raise NotImplementedError("Unknown mode: {0}".format(self.mode))
if self.toolbar.mode in overwriteable_modes:
self.toolbar.mode = self.mode
log.info("Setting mode: {0}".format(self.mode))
def load_plugins(splash=None):
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using "
"setuptools=={0}".format(setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
n_plugins = len(list(iter_plugin_entry_points()))
for iplugin, item in enumerate(iter_plugin_entry_points()):
if item.module_name not in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
try:
function = item.load()
function()
except Exception as exc:
logger.info("Loading plugin {0} failed "
"(Exception: {1})".format(item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
if splash is not None:
splash.set_progress(100. * iplugin / float(n_plugins))
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
# Reload the settings now that we have loaded plugins, since some plugins
# may have added some settings. Note that this will not re-read settings
# that were previously read.
from glue._settings_helpers import load_settings
load_settings()
def load_plugins(splash=None):
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using "
"setuptools=={0}".format(setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
n_plugins = len(list(iter_plugin_entry_points()))
for iplugin, item in enumerate(iter_plugin_entry_points()):
if item.module_name not in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
try:
function = item.load()
function()
except Exception as exc:
logger.info("Loading plugin {0} failed "
"(Exception: {1})".format(item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
if splash is not None:
splash.set_progress(100. * iplugin / float(n_plugins))
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
# Reload the settings now that we have loaded plugins, since some plugins
# may have added some settings. Note that this will not re-read settings
# that were previously read.
from glue._settings_helpers import load_settings
load_settings()
def load_settings():
from glue.config import settings, CFG_DIR
settings_cfg = os.path.join(CFG_DIR, 'settings.cfg')
config = configparser.ConfigParser()
read = config.read(settings_cfg)
if len(read) == 0 or not config.has_section('settings'):
return
for name, value in config.items('settings'):
name = name.upper()
if hasattr(settings, name):
setattr(settings, name, json.loads(value))
else:
logger.info("Unknown setting {0} - skipping".format(name))
def setup():
from glue.logger import logger
try:
import cv2
except ImportError:
logger.info("Could not load webcam importer plugin, since OpenCV is required")
return
from glue.config import importer
from .qt_widget import QtWebcamImporter
@importer("Import from webcam")
def webcam_importer():
wi = QtWebcamImporter()
wi.exec_()
return wi.data
logger.info("Loaded webcam importer plugin")
def main(argv=sys.argv):
opt, args = parse(argv[1:])
if opt.verbose:
logger.setLevel("INFO")
if opt.faulthandler:
import faulthandler
faulthandler.enable()
logger.info("Input arguments: %s", sys.argv)
# Global keywords for Glue startup.
kwargs = {
'config': opt.config,
'maximized': not opt.nomax,
'auto_merge': opt.auto_merge
}
if opt.startup:
kwargs['startup_actions'] = opt.startup.split(',')
if opt.test:
return run_tests()
elif opt.restore:
start_glue(gluefile=args[0], **kwargs)
elif opt.script:
execute_script(args[0])
else:
has_file = len(args) == 1
has_files = len(args) > 1
has_py = has_file and args[0].endswith('.py')
has_glu = has_file and args[0].endswith('.glu')
if has_py:
execute_script(args[0])
elif has_glu:
start_glue(gluefile=args[0], **kwargs)
elif has_file or has_files:
start_glue(datafiles=args, **kwargs)
else:
start_glue(**kwargs)
def load_settings(force=False):
"""
Load the settings from disk.
By default, only settings not already defined in memory are read in, but
by setting ``force=True``, all settings will be read in.
"""
from glue.config import settings, CFG_DIR
settings_cfg = os.path.join(CFG_DIR, 'settings.cfg')
logger.info("Loading settings from {0}".format(settings_cfg))
config = configparser.ConfigParser()
read = config.read(settings_cfg)
if len(read) == 0 or not config.has_section('main'):
return
for name, value in config.items('main'):
name = name.upper()
if name in settings:
if settings.is_default(name) or force:
setattr(settings, name, json.loads(value))
elif not settings.is_default(name):
logger.info("Setting {0} already initialized - skipping".format(name))
else:
logger.info("Unknown setting {0} - skipping".format(name))
def set_new_data(self, data, mask=None):
log.info("Setting new data")
if data.ndim == 3:
x_comp_id = data.world_component_ids[0]
xunit = data.coords.wcs.wcs.cunit[2]
cubedata = data[self._options_widget.y_att]
log.info('cubedata shape: {0}'.format(cubedata.shape))
if mask is not None:
cubedata = np.ma.masked_array(cubedata, ~mask)
meandata = cubedata.mean(axis=2).mean(axis=1)
else:
meandata = np.nanmean(cubedata, axis=(1,2))
log.info('meandata shape: {0}'.format(meandata.shape))
ydata = meandata
xdata = data[x_comp_id][:,0,0]
log.info("xdata shape: {0}".format(xdata.shape))
xdata = u.Quantity(xdata, xunit)
elif data.ndim == 2:
raise ValueError("can't handle images")
elif data.ndim == 1:
x_comp_id = data.world_component_ids[0]
y_comp_id = self._options_widget.y_att
xunit = data.coords.wcs.wcs.cunit[0]
xdata = u.Quantity(data[x_comp_id], xunit)
ydata = data[y_comp_id]
else:
raise ValueError("Data have {0} dimensions. Only 1D and 3D data"
" are supported".format(data.ndim))
self._options_widget.x_att = x_comp_id.label
log.info("Done averaging or loading 1d")
sp = pyspeckit.Spectrum(data=ydata, xarr=xdata)
sp.plotter(axis=self.axes, clear=False, color=data.style.color)
sp.plotter.figure.canvas.manager.toolbar = self.toolbar
sp.plotter.axis.figure.canvas.mpl_connect('button_press_event',
self.click_manager)
self.spectra[data] = sp
self.spectrum = sp
def load_settings(force=False):
"""
Load the settings from disk.
By default, only settings not already defined in memory are read in, but
by setting ``force=True``, all settings will be read in.
"""
from glue.config import settings, CFG_DIR
settings_cfg = os.path.join(CFG_DIR, 'settings.cfg')
logger.info("Loading settings from {0}".format(settings_cfg))
config = configparser.ConfigParser()
read = config.read(settings_cfg)
if len(read) == 0 or not config.has_section('main'):
return
for name, value in config.items('main'):
name = name.upper()
if name in settings:
if settings.is_default(name) or force:
setattr(settings, name, json.loads(value))
elif not settings.is_default(name):
logger.info(
"Setting {0} already initialized - skipping".format(name))
else:
logger.info("Unknown setting {0} - skipping".format(name))
def load_plugins():
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using setuptools=={0}".format(
setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
for item in iter_plugin_entry_points():
if not item.module_name in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
try:
function = item.load()
function()
except Exception as exc:
logger.info("Loading plugin {0} failed (Exception: {1})".format(
item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
def apply_mode(mode):
if mode.viewer.toolbar.mode in ('line_select', 'cont_select'):
assert mode.viewer.spectrum.plotter._active_gui is not None, "No active GUI tool in pyspeckit"
roi = mode.roi()
log.info("ROI: {0}".format(roi))
if isinstance(roi, RectangularROI):
x1 = roi.xmin
x2 = roi.xmax
elif isinstance(roi, XRangeROI):
x1 = roi.min
x2 = roi.max
if x1 > x2:
x1, x2 = x2, x1
mode.viewer.spectrum.plotter._active_gui.selectregion(xmin=x1,
xmax=x2,
highlight=True)
def load_plugins():
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using setuptools=={0}".format(setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
for item in iter_plugin_entry_points():
if not item.module_name in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
try:
function = item.load()
function()
except Exception as exc:
logger.info("Loading plugin {0} failed (Exception: {1})".format(item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
def click_manager(self, event):
"""
Pass events to the appropriate pyspeckit actions
"""
if self.toolbar.mode in ('line_identify', 'line_select', 'cont_select', 'cont_exclude'):
log.info("Toolbar: mode={0}".format(self.toolbar.mode))
if self.mode == 'line_identify':
self.spectrum.specfit.guesspeakwidth(event)
self.spectrum.plotter.refresh()
elif self.mode == 'line_select':
self.spectrum.specfit._selectregion_interactive(event)
elif self.mode == 'cont_select':
self.spectrum.baseline._selectregion_interactive(event)
elif self.mode == 'cont_exclude':
self.spectrum.baseline._selectregion_interactive(event, mark_include=False)
else:
log.info("Not in line fitter mode, clicks do NOTHING.")
else:
log.info("Toolbar: mode={0}".format(self.toolbar.mode))
def load_plugins(splash=None):
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using "
"setuptools=={0}".format(setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
n_plugins = len(list(iter_plugin_entry_points()))
for iplugin, item in enumerate(iter_plugin_entry_points()):
if item.module_name not in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
# We don't use item.load() because that then checks requirements of all
# the imported packages, which can lead to errors like this one that
# don't really matter:
#
# Exception: (pytest 2.6.0 (/Users/tom/miniconda3/envs/py27/lib/python2.7/site-packages),
# Requirement.parse('pytest>=2.8'), set(['astropy']))
#
# Just to be clear, this kind of error does indicate that there is an
# old version of a package in the environment, but this can confuse
# users as importing astropy directly would work (as setuptools then
# doesn't do a stringent test of dependency versions). Often this kind
# of error can occur if there is a conda version of a package and and
# older pip version.
try:
module = import_module(item.module_name)
function = getattr(module, item.attrs[0])
function()
except Exception as exc:
# Here we check that some of the 'core' plugins load well and
# raise an actual exception if not.
if item.module_name in REQUIRED_PLUGINS:
raise
else:
logger.info("Loading plugin {0} failed "
"(Exception: {1})".format(item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
if splash is not None:
splash.set_progress(100. * iplugin / float(n_plugins))
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
# Reload the settings now that we have loaded plugins, since some plugins
# may have added some settings. Note that this will not re-read settings
# that were previously read.
from glue._settings_helpers import load_settings
load_settings()
def load_plugins(splash=None, require_qt_plugins=False):
# Search for plugins installed via entry_points. Basically, any package can
# define plugins for glue, and needs to define an entry point using the
# following format:
#
# entry_points = """
# [glue.plugins]
# webcam_importer=glue_exp.importers.webcam:setup
# vizier_importer=glue_exp.importers.vizier:setup
# dataverse_importer=glue_exp.importers.dataverse:setup
# """
#
# where ``setup`` is a function that does whatever is needed to set up the
# plugin, such as add items to various registries.
import setuptools
logger.info("Loading external plugins using "
"setuptools=={0}".format(setuptools.__version__))
from glue._plugin_helpers import iter_plugin_entry_points, PluginConfig
config = PluginConfig.load()
n_plugins = len(list(iter_plugin_entry_points()))
for iplugin, item in enumerate(iter_plugin_entry_points()):
if item.module_name not in _installed_plugins:
_installed_plugins.add(item.name)
if item.module_name in _loaded_plugins:
logger.info("Plugin {0} already loaded".format(item.name))
continue
if not config.plugins[item.name]:
continue
# We don't use item.load() because that then checks requirements of all
# the imported packages, which can lead to errors like this one that
# don't really matter:
#
# Exception: (pytest 2.6.0 (/Users/tom/miniconda3/envs/py27/lib/python2.7/site-packages),
# Requirement.parse('pytest>=2.8'), set(['astropy']))
#
# Just to be clear, this kind of error does indicate that there is an
# old version of a package in the environment, but this can confuse
# users as importing astropy directly would work (as setuptools then
# doesn't do a stringent test of dependency versions). Often this kind
# of error can occur if there is a conda version of a package and and
# older pip version.
try:
module = import_module(item.module_name)
function = getattr(module, item.attrs[0])
function()
except Exception as exc:
# Here we check that some of the 'core' plugins load well and
# raise an actual exception if not.
if item.module_name in REQUIRED_PLUGINS:
raise
elif item.module_name in REQUIRED_PLUGINS_QT and require_qt_plugins:
raise
else:
logger.info("Loading plugin {0} failed "
"(Exception: {1})".format(item.name, exc))
else:
logger.info("Loading plugin {0} succeeded".format(item.name))
_loaded_plugins.add(item.module_name)
if splash is not None:
splash.set_progress(100. * iplugin / float(n_plugins))
try:
config.save()
except Exception as e:
logger.warn("Failed to load plugin configuration")
# Reload the settings now that we have loaded plugins, since some plugins
# may have added some settings. Note that this will not re-read settings
# that were previously read.
from glue._settings_helpers import load_settings
load_settings()
def receive_message(self, private_key, sender_id, msg_id, mtype, params,
extra):
logger.info(
'SAMP: received message - sender_id={0} msg_id={1} mtype={2} '
'params={3} extra={4}'.format(sender_id, msg_id, mtype, params,
extra))
if mtype.startswith('table.load'):
if self.table_id_exists(params['table-id']):
logger.info('SAMP: table with table-id={0} has already '
'been read in'.format(params['table-id']))
return
logger.info('SAMP: loading table with table-id={0}'.format(
params['table-id']))
if mtype == 'table.load.votable':
data = astropy_tabular_data_votable(params['url'])
elif mtype == 'table.load.fits':
data = astropy_tabular_data_fits(params['url'])
else:
logger.info('SAMP: unknown format {0}'.format(
mtype.split('.')[-1]))
return
data.label = params['name']
data.meta['samp-table-id'] = params['table-id']
self.data_collection.append(data)
elif mtype.startswith('image.load'):
if self.image_id_exists(params['image-id']):
logger.info('SAMP: image with image-id={0} has already '
'been read in'.format(params['image-id']))
return
logger.info('SAMP: loading image with image-id={0}'.format(
params['image-id']))
if mtype == 'image.load.fits':
data = fits_reader(params['url'])
else:
logger.info('SAMP: unknown format {0}'.format(
mtype.split('.')[-1]))
return
data.label = params['name']
data.meta['samp-image-id'] = params['image-id']
self.data_collection.append(data)
elif self.state.highlight_is_selection and mtype == 'table.highlight.row':
data = self.data_from_table_id(params['table-id'])
len(self.data_collection.subset_groups)
subset_state = ElementSubsetState(indices=[params['row']],
data=data)
mode = EditSubsetMode()
mode.update(self.data_collection, subset_state)
elif mtype == 'table.select.rowList':
data = self.data_from_table_id(params['table-id'])
len(self.data_collection.subset_groups)
rows = np.asarray(params['row-list'], dtype=int)
subset_state = ElementSubsetState(indices=rows, data=data)
mode = EditSubsetMode()
mode.update(self.data_collection, subset_state)
elif mtype == 'samp.hub.event.register' or mtype == 'samp.hub.event.unregister':
self.state.on_client_change()
from __future__ import absolute_import, division, print_function
from glue.logger import logger
try:
from dill import dumps, loads
except ImportError:
logger.info("Dill library not installed. Falling back to cPickle")
from glue.external.six.moves.cPickle import dumps, loads
def dicom_reader(source):
"""
Read a DICOM file or a directory with DICOM files
"""
if os.path.isdir(source):
# We are dealing with a directory which should contain DICOM files. At
# this point, we need to check whether the directory contains zero,
# one, or more DICOM datasets.
arrays = {}
for filename in glob.glob(os.path.join(source, '*')):
if is_dicom_file(filename):
logger.info("Reading DICOM data from {0}".format(filename))
ds = pydicom.read_file(filename)
arrays[dicom_label(filename)] = ds.pixel_array
else:
logger.info("Not a DICOM file: {0}".format(filename))
# If there are no DICOM files, we raise an error, and if there is one
# then we are done!
if len(arrays) == 0:
raise Exception("No DICOM files found in directory: {0}".format(source))
elif len(arrays) == 1:
label = list(arrays.keys())[0]
return [Data(array=arrays[label], label=label)]
# We now check whether all the shapes of the DICOM files are the same,
# and if so, we merge them into a single file.
labels = sorted(arrays)
ref_shape = arrays[labels[0]].shape
for label in labels[1:]:
if arrays[label].shape != ref_shape:
break
else:
# Since we are here, the shapes of all the DICOM files match, so
# we can construct a higher-dimensional array.
# Make sure arrays are sorted while constructing array
array = np.array([arrays[label] for label in labels])
# We flip the array here on that in most cases we expect that the
# scan will start at the top of e.g. the body and move downwards.
array = array[::-1]
return [Data(array=array, label=dicom_label(source))]
# If we are here, the shapes of the DICOM files didn't match, so we
# simply return one Data object per DICOM file.
return [Data(array=arrays[label], label=label) for label in labels]
else:
ds = pydicom.read_file(source)
data = [Data(array=ds.pixel_array, label=dicom_label(source))]
return data
from __future__ import absolute_import, division, print_function
from glue.logger import logger
try:
from dill import dumps, loads # noqa
except ImportError:
logger.info("Dill library not installed. Falling back to cPickle")
from glue.external.six.moves.cPickle import dumps, loads # noqa
