def qglue(**kwargs):
"""
Quickly send python variables to Glue for visualization.
The generic calling sequence is::
qglue(label1=data1, label2=data2, ..., [links=links])
The kewyords label1, label2, ... can be named anything besides ``links``
data1, data2, ... can be in many formats:
* A pandas data frame
* A path to a file
* A numpy array, or python list
* A numpy rec array
* A dictionary of numpy arrays with the same shape
* An astropy Table
``Links`` is an optional list of link descriptions, each of which has
the format: ([left_ids], [right_ids], forward, backward)
Each ``left_id``/``right_id`` is a string naming a component in a dataset
(i.e., ``data1.x``). ``forward`` and ``backward`` are functions which
map quantities on the left to quantities on the right, and vice
versa. `backward` is optional
Examples::
balls = {'kg': [1, 2, 3], 'radius_cm': [10, 15, 30]}
cones = {'lbs': [5, 3, 3, 1]}
def lb2kg(lb):
return lb / 2.2
def kg2lb(kg):
return kg * 2.2
links = [(['balls.kg'], ['cones.lbs'], lb2kg, kg2lb)]
qglue(balls=balls, cones=cones, links=links)
:returns: A :class:`~glue.app.qt.application.GlueApplication` object
"""
from glue.core import DataCollection
from glue.app.qt import GlueApplication
from glue.dialogs.autolinker.qt import run_autolinker
links = kwargs.pop('links', None)
dc = DataCollection()
for label, data in kwargs.items():
dc.extend(parse_data(data, label))
if links is not None:
dc.add_link(parse_links(dc, links))
with restore_io():
ga = GlueApplication(dc)
run_autolinker(dc)
ga.start()
return ga
def qglue(**kwargs):
"""
Quickly send python variables to Glue for visualization.
The generic calling sequence is::
qglue(label1=data1, label2=data2, ..., [links=links])
The kewyords label1, label2, ... can be named anything besides ``links``
data1, data2, ... can be in many formats:
* A pandas data frame
* A path to a file
* A numpy array, or python list
* A numpy rec array
* A dictionary of numpy arrays with the same shape
* An astropy Table
``Links`` is an optional list of link descriptions, each of which has
the format: ([left_ids], [right_ids], forward, backward)
Each ``left_id``/``right_id`` is a string naming a component in a dataset
(i.e., ``data1.x``). ``forward`` and ``backward`` are functions which
map quantities on the left to quantities on the right, and vice
versa. `backward` is optional
Examples::
balls = {'kg': [1, 2, 3], 'radius_cm': [10, 15, 30]}
cones = {'lbs': [5, 3, 3, 1]}
def lb2kg(lb):
return lb / 2.2
def kg2lb(kg):
return kg * 2.2
links = [(['balls.kg'], ['cones.lbs'], lb2kg, kg2lb)]
qglue(balls=balls, cones=cones, links=links)
:returns: A :class:`~glue.app.qt.application.GlueApplication` object
"""
from glue.core import DataCollection
from glue.app.qt import GlueApplication
links = kwargs.pop('links', None)
dc = DataCollection()
for label, data in kwargs.items():
dc.extend(parse_data(data, label))
if links is not None:
dc.add_link(parse_links(dc, links))
with restore_io():
ga = GlueApplication(dc)
ga.start()
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.
"""
# 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')
ga.start(maximized=True)
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
"""
import glue
from glue.app.qt import GlueApplication
# 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()
datafiles = datafiles or []
hub = None
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session, maximized=maximized)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets)
# ga.show()
# splash.close()
# ga.raise_()
# QApplication.instance().processEvents()
return ga.start()
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
"""
import glue
from glue.app.qt import GlueApplication
# 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()
datafiles = datafiles or []
hub = None
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session, maximized=maximized)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets)
# ga.show()
# splash.close()
# ga.raise_()
# QApplication.instance().processEvents()
return ga.start()
def start_glue(gluefile=None, config=None, datafiles=None):
"""Run a glue session and exit
:param gluefile: An optional .glu file to restore
:type gluefile: str
:param config: An optional configuration file to use
:type config: str
:param datafiles: An optional list of data files to load
:type datafiles: list of str
"""
import glue
from glue.app.qt import GlueApplication
# 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()
datafiles = datafiles or []
data, hub = None, None
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets)
# ga.show()
# splash.close()
# ga.raise_()
# QApplication.instance().processEvents()
return ga.start()
def start_glue(gluefile=None, config=None, datafiles=None):
"""Run a glue session and exit
:param gluefile: An optional .glu file to restore
:type gluefile: str
:param config: An optional configuration file to use
:type config: str
:param datafiles: An optional list of data files to load
:type datafiles: list of str
"""
import glue
from glue.app.qt import GlueApplication
# 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()
datafiles = datafiles or []
data, hub = None, None
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets)
# ga.show()
# splash.close()
# ga.raise_()
# QApplication.instance().processEvents()
return ga.start()
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True,
startup_actions=None, auto_merge=False):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
auto_merge : bool, optional
Whether to automatically merge data passed in `datafiles` (default is `False`)
"""
import glue
# Some Qt modules are picky in terms of being imported before the
# application is set up, so we import them here. We do it here rather
# than in get_qapp since in the past, including this code in get_qapp
# caused severe issues (e.g. segmentation faults) in plugin packages
# during testing.
try:
from qtpy import QtWebEngineWidgets # noqa
except ImportError: # Not all PyQt installations have this module
pass
from glue.utils.qt.decorators import die_on_error
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
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, require_qt_plugins=True)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if gluefile is not None:
with die_on_error("Error restoring Glue session"):
app = GlueApplication.restore_session(gluefile, show=False)
return app.start(maximized=maximized)
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
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)
if datafiles:
with die_on_error("Error reading data file"):
datasets = load_data_files(datafiles)
ga.add_datasets(datasets, auto_merge=auto_merge)
if startup_actions is not None:
for name in startup_actions:
ga.run_startup_action(name)
return ga.start(maximized=maximized)
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
"""
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
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)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
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)
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets)
return ga.start(maximized=maximized)
def start_glue(gluefile=None,
config=None,
datafiles=None,
maximized=True,
startup_actions=None,
auto_merge=False):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
auto_merge : bool, optional
Whether to automatically merge data passed in `datafiles` (default is `False`)
"""
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
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)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
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)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=auto_merge)
if startup_actions is not None:
for name in startup_actions:
ga.run_startup_action(name)
return ga.start(maximized=maximized)
@data_factory('yt dataset', is_yt_dataset)
def read_yt(filename):
ds = yt.load(filename)
return YTGlueData(ds)
if __name__ == "__main__":
ds = yt.load('Enzo_64/DD0043/data0043')
def logdensity(field, data):
return np.log10(data['gas', 'density'])
ds.add_field(('gas', 'logdensity'),
function=logdensity,
units='',
sampling_type='cell')
def logtemperature(field, data):
return np.log10(data['gas', 'temperature'])
ds.add_field(('gas', 'logtemperature'),
function=logtemperature,
units='',
sampling_type='cell')
d1 = YTGlueData(ds)
dc = DataCollection([d1])
ga = GlueApplication(dc)
viewer = ga.new_data_viewer(VispyVolumeViewer)
viewer.add_data(d1)
ga.start(maximized=False)
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True,
startup_actions=None, auto_merge=False):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
auto_merge : bool, optional
Whether to automatically merge data passed in `datafiles` (default is `False`)
"""
import glue
# Some Qt modules are picky in terms of being imported before the
# application is set up, so we import them here. We do it here rather
# than in get_qapp since in the past, including this code in get_qapp
# caused severe issues (e.g. segmentation faults) in plugin packages
# during testing.
try:
from qtpy import QtWebEngineWidgets # noqa
except ImportError: # Not all PyQt installations have this module
pass
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
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)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
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)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=auto_merge)
if startup_actions is not None:
for name in startup_actions:
ga.run_startup_action(name)
return ga.start(maximized=maximized)
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))
