def pytest_configure(config):
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Start up QApplication, if the Qt code is present
try:
from glue.utils.qt import get_qapp
except ImportError:
pass
else:
get_qapp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def pytest_configure(config):
os.environ['GLUE_TESTING'] = 'True'
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Start up QApplication, if the Qt code is present
try:
from glue.utils.qt import get_qapp
except Exception:
# Note that we catch any exception, not just ImportError, because
# QtPy can raise a PythonQtError.
pass
else:
get_qapp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def __init__(self, data_collection=None, session=None, settings=None):
super(JupyterApplication,
self).__init__(data_collection=data_collection, session=session)
try:
from glue.main import load_plugins
load_plugins()
except Exception: # Compatibility with glue <0.16
from glue.main import REQUIRED_PLUGINS
REQUIRED_PLUGINS.clear()
load_plugins()
self.output = widgets.Output()
self.widget_data_collection = widgets.SelectMultiple()
self.widget_subset_select = SubsetSelect(session=self.session)
self.widget_subset_mode = SelectionModeMenu(session=self.session)
self.widget = widgets.VBox(
children=[self.widget_subset_mode, self.output])
self._settings['new_subset_on_selection_tool_change'] = [
False, is_bool
]
if settings is not None:
for key, value in settings.items():
self.set_setting(key, value)
self._viewer_refs = []
def pytest_configure(config):
os.environ['GLUE_TESTING'] = 'True'
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Start up QApplication, if the Qt code is present
try:
from glue.utils.qt import get_qapp
except Exception:
# Note that we catch any exception, not just ImportError, because
# QtPy can raise a PythonQtError.
pass
else:
get_qapp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def pytest_configure(config):
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Start up QApplication, if the Qt code is present
try:
from glue.external.qt import get_qapp
except ImportError:
pass
else:
app = get_qapp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def __init__(self, data_collection=None, session=None):
# At this point we need to check if a Qt application already exists -
# this happens for example if using the %gui qt/qt5 mode in Jupyter. We
# should keep a reference to the original icon so that we can restore it
# later
self._original_app = QtWidgets.QApplication.instance()
if self._original_app is not None:
self._original_icon = self._original_app.windowIcon()
self._export_helper = ExportHelper(self)
self._import_helper = ImportHelper(self)
# Now we can get the application instance, which involves setting it
# up if it doesn't already exist.
self.app = get_qapp()
QtWidgets.QMainWindow.__init__(self)
Application.__init__(self,
data_collection=data_collection,
session=session)
# Pull in any keybindings from an external file
self.keybindings = keyboard_shortcut
icon = get_icon('app_icon')
self.app.setWindowIcon(icon)
# Even though we loaded the plugins in start_glue, we re-load them here
# in case glue was started directly by initializing this class.
load_plugins(require_qt_plugins=True)
self.setWindowTitle("Glue")
self.setWindowIcon(icon)
self.setAttribute(Qt.WA_DeleteOnClose)
self._actions = {}
self._terminal = None
self._setup_ui()
self.tab_widget.setMovable(True)
self.tab_widget.setTabsClosable(True)
# The following is a counter that never goes down, even if tabs are
# deleted (this is by design, to avoid having two tabs called the
# same if a tab is removed then a new one added again)
self._total_tab_count = 0
lwidget = self._layer_widget
a = PlotAction(lwidget, self)
lwidget.ui.layerTree.addAction(a)
self._tweak_geometry()
self._create_actions()
self._create_menu()
self._connect()
self.new_tab()
self._update_viewer_in_focus()
def main(argv=sys.argv):
"""
The majority of the code in this function was taken from start_glue() in main.py after a discussion with
Tom Robataille. We wanted the ability to get command line arguments and use them in here and this seemed
to be the cleanest way to do it.
"""
# Make sure the mosviz startup item is registered
from .startup import mosviz_setup # noqa
parser = argparse.ArgumentParser()
parser.add_argument('data_files', nargs=argparse.REMAINDER)
args = parser.parse_known_args(argv[1:])
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
# Splash screen
splash = get_splash()
splash.image = QtGui.QPixmap(MOSVIZ_SPLASH_PATH)
splash.show()
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
datafiles = args[0].data_files
# # Show the splash screen for 2 seconds
timer = QTimer()
timer.setInterval(2000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
splash.set_progress(100)
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
qapp = QtWidgets.QApplication.instance()
ga.setWindowTitle('MOSViz v{0}'.format(__version__))
qapp.setWindowIcon(QtGui.QIcon(MOSVIZ_ICON_PATH))
ga.setWindowIcon(QtGui.QIcon(MOSVIZ_ICON_PATH))
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
ga.run_startup_action('mosviz')
sys.exit(ga.start(maximized=True))
def __init__(self, data_collection=None, session=None):
# At this point we need to check if a Qt application already exists -
# this happens for example if using the %gui qt/qt5 mode in Jupyter. We
# should keep a reference to the original icon so that we can restore it
# later
self._original_app = QtWidgets.QApplication.instance()
if self._original_app is not None:
self._original_icon = self._original_app.windowIcon()
self._export_helper = ExportHelper(self)
self._import_helper = ImportHelper(self)
# Now we can get the application instance, which involves setting it
# up if it doesn't already exist.
self.app = get_qapp()
QtWidgets.QMainWindow.__init__(self)
Application.__init__(self, data_collection=data_collection,
session=session)
# Pull in any keybindings from an external file
self.keybindings = keyboard_shortcut
icon = get_icon('app_icon')
self.app.setWindowIcon(icon)
# Even though we loaded the plugins in start_glue, we re-load them here
# in case glue was started directly by initializing this class.
load_plugins()
self.setWindowTitle("Glue")
self.setWindowIcon(icon)
self.setAttribute(Qt.WA_DeleteOnClose)
self._actions = {}
self._terminal = None
self._setup_ui()
self.tab_widget.setMovable(True)
self.tab_widget.setTabsClosable(True)
# The following is a counter that never goes down, even if tabs are
# deleted (this is by design, to avoid having two tabs called the
# same if a tab is removed then a new one added again)
self._total_tab_count = 0
lwidget = self._layer_widget
a = PlotAction(lwidget, self)
lwidget.ui.layerTree.addAction(a)
self._tweak_geometry()
self._create_actions()
self._create_menu()
self._connect()
self.new_tab()
self._update_viewer_in_focus()
def gs9(data, vmin, vmax, percentile, stretch, cmap):
load_plugins()
if cmap is not None:
for cmap_name, cmap_obj in colormaps.members:
if cmap == cmap_name:
cmap = cmap_obj
break
else:
colormaps.add(cmap, cm.get_cmap(cmap))
cmap = cm.get_cmap(cmap)
ga = GlueApplication()
image = ga.new_data_viewer(ImageViewer)
datasets = []
for filename in data:
datasets.append(load_data(filename))
# Add datasets all in one go to do all linking in one pass
ga.add_datasets(datasets)
for d in ga.data_collection:
image.add_data(d)
for layer_state in image.state.layers:
if vmin is not None:
layer_state.v_min = vmin
if vmax is not None:
layer_state.v_min = vmax
if percentile is not None:
choices = ImageLayerState.percentile.get_choices(layer_state)
for choice in choices:
if percentile == choice:
percentile = choice
break
layer_state.percentile = percentile
if stretch is not None:
layer_state.stretch = stretch
if cmap is not None:
layer_state.cmap = cmap
image.viewer_size = (600, 600)
ga.gather_current_tab()
ga.start(maximized=False, size=(1024, 768))
def __init__(self, data_collection=None, session=None):
super(JupyterApplication, self).__init__(data_collection=data_collection, session=session)
try:
from glue.main import load_plugins
load_plugins()
except Exception: # Compatibility with glue <0.16
from glue.main import REQUIRED_PLUGINS
REQUIRED_PLUGINS.clear()
load_plugins()
self.output = widgets.Output()
self.widget_data_collection = widgets.SelectMultiple()
self.widget_subset_select = SubsetSelect(session=self.session)
self.widget_subset_mode = SelectionModeMenu(session=self.session)
self.widget = widgets.VBox(children=[self.widget_subset_mode, self.output])
def main(): # pragma: no cover
import numpy as np
from glue.main import load_plugins
from glue.utils.qt import get_qapp
from glue.core import Data, DataCollection
load_plugins()
app = get_qapp()
dc = DataCollection()
for i in range(10):
x = np.array([1, 2, 3])
d = Data(label='data_{0:02d}'.format(i), x=x, y=x * 2)
dc.append(d)
LinkEditor.update_links(dc)
def main(): # pragma: no cover
import numpy as np
from glue.main import load_plugins
from glue.utils.qt import get_qapp
from glue.core import Data, DataCollection
load_plugins()
app = get_qapp()
dc = DataCollection()
for i in range(10):
x = np.array([1, 2, 3])
d = Data(label='data_{0:02d}'.format(i), x=x, y=x * 2)
dc.append(d)
LinkEditor.update_links(dc)
def pytest_configure(config):
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def __init__(self, data_collection=None, session=None):
self.app = get_qapp()
QtGui.QMainWindow.__init__(self)
Application.__init__(self,
data_collection=data_collection,
session=session)
self.app.setQuitOnLastWindowClosed(True)
pth = os.path.abspath(os.path.dirname(__file__))
pth = os.path.join(pth, 'icons', 'app_icon.png')
self.app.setWindowIcon(QtGui.QIcon(pth))
# Even though we loaded the plugins in start_glue, we re-load them here
# in case glue was started directly by initializing this class.
load_plugins()
self.setWindowIcon(self.app.windowIcon())
self.setAttribute(Qt.WA_DeleteOnClose)
self._actions = {}
self._terminal = None
self._setup_ui()
self.tab_widget.setMovable(True)
self.tab_widget.setTabsClosable(True)
# The following is a counter that never goes down, even if tabs are
# deleted (this is by design, to avoid having two tabs called the
# same if a tab is removed then a new one added again)
self._total_tab_count = 0
lwidget = self._ui.layerWidget
a = PlotAction(lwidget, self)
lwidget.layerTree.addAction(a)
lwidget.bind_selection_to_edit_subset()
self._tweak_geometry()
self._create_actions()
self._create_menu()
self._connect()
self.new_tab()
self._update_plot_dashboard(None)
self._load_settings()
def __init__(self, data_collection=None, session=None):
self.app = get_qapp()
QtGui.QMainWindow.__init__(self)
Application.__init__(self, data_collection=data_collection,
session=session)
self.app.setQuitOnLastWindowClosed(True)
icon = get_icon('app_icon')
self.app.setWindowIcon(icon)
# Even though we loaded the plugins in start_glue, we re-load them here
# in case glue was started directly by initializing this class.
load_plugins()
self.setWindowTitle("Glue")
self.setWindowIcon(icon)
self.setAttribute(Qt.WA_DeleteOnClose)
self._actions = {}
self._terminal = None
self._setup_ui()
self.tab_widget.setMovable(True)
self.tab_widget.setTabsClosable(True)
# The following is a counter that never goes down, even if tabs are
# deleted (this is by design, to avoid having two tabs called the
# same if a tab is removed then a new one added again)
self._total_tab_count = 0
lwidget = self._layer_widget
a = PlotAction(lwidget, self)
lwidget.ui.layerTree.addAction(a)
lwidget.bind_selection_to_edit_subset()
self._tweak_geometry()
self._create_actions()
self._create_menu()
self._connect()
self.new_tab()
self._update_plot_dashboard(None)
self._load_settings()
def create_app(datafiles=[], interactive=True):
app = get_qapp()
if interactive:
# Splash screen
splash = get_splash()
splash.image = QtGui.QPixmap(MOSVIZ_SPLASH_PATH)
splash.show()
else:
splash = None
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
# # Show the splash screen for 2 seconds
if interactive:
timer = QTimer()
timer.setInterval(2000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
if interactive:
splash.set_progress(100)
ga = _create_glue_app(data_collection, hub)
ga.run_startup_action('mosviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
return ga
def create_app(datafiles=[], interactive=True):
app = get_qapp()
if interactive:
# Splash screen
splash = get_splash()
splash.image = QtGui.QPixmap(MOSVIZ_SPLASH_PATH)
splash.show()
else:
splash = None
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
# # Show the splash screen for 2 seconds
if interactive:
timer = QTimer()
timer.setInterval(2000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
if interactive:
splash.set_progress(100)
ga = _create_glue_app(data_collection, hub)
ga.run_startup_action('mosviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
return ga
def test_basic(tmpdir):
# Test that things work when the plugin cfg file is populated
from glue import config
config.CFG_DIR = tmpdir.join('.glue').strpath
load_plugins()
config = ph.PluginConfig.load()
config.plugins['spectrum_tool'] = False
config.plugins['pv_slicer'] = False
config.save()
w = QtPluginManager()
w.clear()
w.update_list()
w.finalize()
config2 = ph.PluginConfig.load()
assert config.plugins == config2.plugins
def create_app(datafiles=[], data_configs=[], data_configs_show=False,
interactive=True):
"""
Create and initialize a cubeviz application instance
Parameters
----------
datafiles : `list`
A list of filenames representing data files to be loaded
data_configs : `list`
A list of filenames representing data configuration files to be used
data_configs_show : `bool`
Display matching info about data configuration files
interactive : `bool`
Flag to indicate whether session is interactive or not (i.e. for testing)
"""
app = get_qapp()
# Splash screen
if interactive:
splash = get_splash()
splash.image = QtGui.QPixmap(CUBEVIZ_LOGO_PATH)
splash.show()
else:
splash = None
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
dfc_kwargs = dict(remove_defaults=True, check_ifu_valid=interactive)
DataFactoryConfiguration(data_configs, data_configs_show, **dfc_kwargs)
# Check to make sure each file exists and raise an Exception
# that will show in the popup if it does not exist.
_check_datafiles_exist(datafiles)
# Show the splash screen for 1 second
if interactive:
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
ga = _create_glue_app(data_collection, hub)
ga.run_startup_action('cubeviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
if interactive:
splash.set_progress(100)
return ga
def main(argv=sys.argv):
"""
The majority of the code in this function was taken from start_glue() in main.py after a discussion with
Tom Robataille. We wanted the ability to get command line arguments and use them in here and this seemed
to be the cleanest way to do it.
:param argv:
:return:
"""
# # Parse the arguments, ignore any unkonwn
parser = argparse.ArgumentParser()
parser.add_argument("--data-configs", help="Directory or file for data configuration YAML files", action='append', default=[])
parser.add_argument("--data-configs-show", help="Show the matching info", action="store_true", default=False)
parser.add_argument('data_files', nargs=argparse.REMAINDER)
args = parser.parse_known_args(argv[1:])
# Store the args for each ' --data-configs' found on the commandline
data_configs = args[0].data_configs
data_configs_show = args[0].data_configs_show
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
# Splash screen
splash = get_splash()
splash.image = QtGui.QPixmap(CUBEVIZ_LOGO_PATH)
splash.show()
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
# Load the
DataFactoryConfiguration(data_configs, data_configs_show, remove_defaults=True)
datafiles = args[0].data_files
# Check to make sure each file exists and raise an Exception
# that will show in the popup if it does not exist.
for fileparam in datafiles:
for filename in fileparam.split(','):
if not os.path.isfile(filename.strip()):
raise IOError('The file {} does not exist'.format(filename))
# Show the splash screen for 1 second
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
splash.set_progress(100)
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
ga.setWindowTitle('cubeviz ({})'.format(cubeviz_version))
qapp = QtWidgets.QApplication.instance()
qapp.setWindowIcon(QtGui.QIcon(CUBEVIZ_ICON_PATH))
ga.setWindowIcon(QtGui.QIcon(CUBEVIZ_ICON_PATH))
ga.run_startup_action('cubeviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
sys.exit(ga.start(maximized=True))
def create_app(datafiles=[],
data_configs=[],
data_configs_show=False,
interactive=True):
"""
Create and initialize a cubeviz application instance
Parameters
----------
datafiles : `list`
A list of filenames representing data files to be loaded
data_configs : `list`
A list of filenames representing data configuration files to be used
data_configs_show : `bool`
Display matching info about data configuration files
interactive : `bool`
Flag to indicate whether session is interactive or not (i.e. for testing)
"""
app = get_qapp()
# Splash screen
if interactive:
splash = get_splash()
splash.image = QtGui.QPixmap(CUBEVIZ_LOGO_PATH)
splash.show()
else:
splash = None
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
dfc_kwargs = dict(remove_defaults=True, check_ifu_valid=interactive)
DataFactoryConfiguration(data_configs, data_configs_show, **dfc_kwargs)
# Check to make sure each file exists and raise an Exception
# that will show in the popup if it does not exist.
_check_datafiles_exist(datafiles)
# Show the splash screen for 1 second
if interactive:
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
ga = _create_glue_app(data_collection, hub)
ga.run_startup_action('cubeviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
if interactive:
splash.set_progress(100)
return ga
