Skip to content

Commit

Permalink
gui: basic support for opening files outside repository
Browse files Browse the repository at this point in the history
sbourdeauducq committed Dec 8, 2015
1 parent 238ee9a commit 0da8955
Showing 3 changed files with 187 additions and 129 deletions.
203 changes: 119 additions & 84 deletions artiq/gui/experiments.py
Original file line number Diff line number Diff line change
@@ -118,10 +118,16 @@ def default_state(procdesc):
}


# Experiment URLs come in two forms:
# 1. repo:<experiment name>
# (file name and class name to be retrieved from explist)
# 2. file:<class name>@<file name>


class _ArgumentEditor(QtGui.QTreeWidget):
def __init__(self, manager, dock, expname):
def __init__(self, manager, dock, expurl):
self.manager = manager
self.expname = expname
self.expurl = expurl

QtGui.QTreeWidget.__init__(self)
self.setColumnCount(3)
@@ -137,7 +143,7 @@ def __init__(self, manager, dock, expname):
self._groups = dict()
self._arg_to_entry_widgetitem = dict()

arguments = self.manager.get_submission_arguments(self.expname)
arguments = self.manager.get_submission_arguments(self.expurl)

if not arguments:
self.addTopLevelItem(QtGui.QTreeWidgetItem(["No arguments"]))
@@ -194,11 +200,11 @@ def _recompute_argument_clicked(self, name):

async def _recompute_argument(self, name):
try:
arginfo = await self.manager.recompute_arginfo(self.expname)
arginfo = await self.manager.compute_arginfo(self.expurl)
except:
logger.warning("Could not recompute argument '%s' of '%s'",
name, self.expname, exc_info=True)
argument = self.manager.get_submission_arguments(self.expname)[name]
name, self.expurl, exc_info=True)
argument = self.manager.get_submission_arguments(self.expurl)[name]

procdesc = arginfo[name][0]
state = _argty_to_entry[procdesc["ty"]].default_state(procdesc)
@@ -228,21 +234,21 @@ def restore_state(self, state):


class _ExperimentDock(dockarea.Dock):
def __init__(self, manager, expname):
dockarea.Dock.__init__(self, "Exp: " + expname,
def __init__(self, manager, expurl):
dockarea.Dock.__init__(self, "Exp: " + expurl,
closable=True, size=(1500, 500))
self.layout.setSpacing(5)
self.layout.setContentsMargins(5, 5, 5, 5)

self.manager = manager
self.expname = expname
self.expurl = expurl

self.argeditor = _ArgumentEditor(self.manager, self, self.expname)
self.argeditor = _ArgumentEditor(self.manager, self, self.expurl)
self.addWidget(self.argeditor, 0, 0, colspan=5)
self.layout.setRowStretch(0, 1)

scheduling = manager.get_submission_scheduling(expname)
options = manager.get_submission_options(expname)
scheduling = manager.get_submission_scheduling(expurl)
options = manager.get_submission_options(expurl)

datetime = QtGui.QDateTimeEdit()
datetime.setDisplayFormat("MMM d yyyy hh:mm:ss")
@@ -312,23 +318,23 @@ def update_log_level(index):
options["log_level"] = getattr(logging, log_level.currentText())
log_level.currentIndexChanged.connect(update_log_level)

repo_rev = QtGui.QLineEdit()
repo_rev.setPlaceholderText("current")
repo_rev_label = QtGui.QLabel("Revision:")
repo_rev_label.setToolTip("Experiment repository revision "
"(commit ID) to use")
self.addWidget(repo_rev_label, 3, 2)
self.addWidget(repo_rev, 3, 3)

if options["repo_rev"] is not None:
repo_rev.setText(options["repo_rev"])
def update_repo_rev():
t = repo_rev.text()
if t:
options["repo_rev"] = t
else:
options["repo_rev"] = None
repo_rev.editingFinished.connect(update_repo_rev)
if "repo_rev" in options:
repo_rev = QtGui.QLineEdit()
repo_rev.setPlaceholderText("current")
repo_rev_label = QtGui.QLabel("Revision:")
repo_rev_label.setToolTip("Experiment repository revision "
"(commit ID) to use")
self.addWidget(repo_rev_label, 3, 2)
self.addWidget(repo_rev, 3, 3)

if options["repo_rev"] is not None:
repo_rev.setText(options["repo_rev"])
def update_repo_rev(text):
if text:
options["repo_rev"] = text
else:
options["repo_rev"] = None
repo_rev.textEdited.connect(update_repo_rev)

submit = QtGui.QPushButton("Submit")
submit.setIcon(QtGui.QApplication.style().standardIcon(
@@ -352,35 +358,35 @@ def update_repo_rev():

def submit_clicked(self):
try:
self.manager.submit(self.expname)
self.manager.submit(self.expurl)
except:
# May happen when experiment has been removed
# from repository/explist
logger.warning("failed to submit '%s'",
self.expname, exc_info=True)
self.expurl, exc_info=True)

def reqterm_clicked(self):
try:
self.manager.request_inst_term(self.expname)
self.manager.request_inst_term(self.expurl)
except:
# May happen when experiment has been removed
# from repository/explist
logger.warning("failed to request termination of instances of '%s'",
self.expname, exc_info=True)
self.expurl, exc_info=True)

def _recompute_arguments_clicked(self):
asyncio.ensure_future(self._recompute_arguments_task())

async def _recompute_arguments_task(self):
try:
arginfo = await self.manager.recompute_arginfo(self.expname)
arginfo = await self.manager.compute_arginfo(self.expurl)
except:
logger.warning("Could not recompute arguments of '%s'",
self.expname, exc_info=True)
self.manager.initialize_submission_arguments(self.expname, arginfo)
self.expurl, exc_info=True)
self.manager.initialize_submission_arguments(self.expurl, arginfo)

self.argeditor.deleteLater()
self.argeditor = _ArgumentEditor(self.manager, self, self.expname)
self.argeditor = _ArgumentEditor(self.manager, self, self.expurl)
self.addWidget(self.argeditor, 0, 0, colspan=5)

def save_state(self):
@@ -416,9 +422,19 @@ def set_explist_model(self, model):
def set_schedule_model(self, model):
self.schedule = model.backing_store

def get_submission_scheduling(self, expname):
if expname in self.submission_scheduling:
return self.submission_scheduling[expname]
def resolve_expurl(self, expurl):
if expurl[:5] == "repo:":
expinfo = self.explist[expurl[5:]]
return expinfo["file"], expinfo["class_name"], True
elif expurl[:5] == "file:":
class_name, file = expurl[5:].split("@", maxsplit=1)
return file, class_name, False
else:
raise ValueError("Malformed experiment URL")

def get_submission_scheduling(self, expurl):
if expurl in self.submission_scheduling:
return self.submission_scheduling[expurl]
else:
# mutated by _ExperimentDock
scheduling = {
@@ -427,22 +443,23 @@ def get_submission_scheduling(self, expname):
"due_date": None,
"flush": False
}
self.submission_scheduling[expname] = scheduling
self.submission_scheduling[expurl] = scheduling
return scheduling

def get_submission_options(self, expname):
if expname in self.submission_options:
return self.submission_options[expname]
def get_submission_options(self, expurl):
if expurl in self.submission_options:
return self.submission_options[expurl]
else:
# mutated by _ExperimentDock
options = {
"log_level": logging.WARNING,
"repo_rev": None
"log_level": logging.WARNING
}
self.submission_options[expname] = options
if expurl[:5] == "repo:":
options["repo_rev"] = None
self.submission_options[expurl] = options
return options

def initialize_submission_arguments(self, expname, arginfo):
def initialize_submission_arguments(self, expurl, arginfo):
arguments = OrderedDict()
for name, (procdesc, group) in arginfo.items():
state = _argty_to_entry[procdesc["ty"]].default_state(procdesc)
@@ -451,39 +468,42 @@ def initialize_submission_arguments(self, expname, arginfo):
"group": group,
"state": state # mutated by entries
}
self.submission_arguments[expname] = arguments
self.submission_arguments[expurl] = arguments
return arguments

def get_submission_arguments(self, expname):
if expname in self.submission_arguments:
return self.submission_arguments[expname]
def get_submission_arguments(self, expurl):
if expurl in self.submission_arguments:
return self.submission_arguments[expurl]
else:
arginfo = self.explist[expname]["arginfo"]
arguments = self.initialize_submission_arguments(arginfo)
if expurl[:5] != "repo:":
raise ValueError("Submission arguments must be preinitialized "
"when not using repository")
arginfo = self.explist[expurl[5:]]["arginfo"]
arguments = self.initialize_submission_arguments(expurl, arginfo)
return arguments

def open_experiment(self, expname):
if expname in self.open_experiments:
return self.open_experiments[expname]
dock = _ExperimentDock(self, expname)
self.open_experiments[expname] = dock
def open_experiment(self, expurl):
if expurl in self.open_experiments:
return self.open_experiments[expurl]
dock = _ExperimentDock(self, expurl)
self.open_experiments[expurl] = dock
self.dock_area.addDock(dock)
self.dock_area.floatDock(dock)
dock.sigClosed.connect(partial(self.on_dock_closed, expname))
dock.sigClosed.connect(partial(self.on_dock_closed, expurl))
return dock

def on_dock_closed(self, expname):
del self.open_experiments[expname]
def on_dock_closed(self, expurl):
del self.open_experiments[expurl]

async def _submit_task(self, *args):
rid = await self.schedule_ctl.submit(*args)
self.status_bar.showMessage("Submitted RID {}".format(rid))

def submit(self, expname):
expinfo = self.explist[expname]
scheduling = self.get_submission_scheduling(expname)
options = self.get_submission_options(expname)
arguments = self.get_submission_arguments(expname)
def submit(self, expurl):
file, class_name, _ = self.resolve_expurl(expurl)
scheduling = self.get_submission_scheduling(expurl)
options = self.get_submission_options(expurl)
arguments = self.get_submission_arguments(expurl)

argument_values = dict()
for name, argument in arguments.items():
@@ -492,11 +512,12 @@ def submit(self, expname):

expid = {
"log_level": options["log_level"],
"repo_rev": options["repo_rev"],
"file": expinfo["file"],
"class_name": expinfo["class_name"],
"file": file,
"class_name": class_name,
"arguments": argument_values,
}
if "repo_rev" in options:
expid["repo_rev"] = options["repo_rev"]
asyncio.ensure_future(self._submit_task(
scheduling["pipeline_name"],
expid,
@@ -513,27 +534,41 @@ async def _request_term_multiple(self, rids):
logger.debug("failed to request termination of RID %d",
rid, exc_info=True)

def request_inst_term(self, expname):
def request_inst_term(self, expurl):
self.status_bar.showMessage("Requesting termination of all instances "
"of '{}'".format(expname))
expinfo = self.explist[expname]
"of '{}'".format(expurl))
file, class_name, use_repository = self.resolve_expurl(expurl)
rids = []
for rid, desc in self.schedule.items():
expid = desc["expid"]
if ("repo_rev" in expid # only consider runs from repository
and expid["file"] == expinfo["file"]
and expid["class_name"] == expinfo["class_name"]):
if use_repository:
repo_match = "repo_rev" in expid
else:
repo_match = "repo_rev" not in expid
if (repo_match
and expid["file"] == file
and expid["class_name"] == class_name):
rids.append(rid)
asyncio.ensure_future(self._request_term_multiple(rids))

async def recompute_arginfo(self, expname):
expinfo = self.explist[expname]
description = await self.experiment_db_ctl.examine(expinfo["file"])
return description[expinfo["class_name"]]["arginfo"]
async def compute_arginfo(self, expurl):
file, class_name, use_repository = self.resolve_expurl(expurl)
description = await self.experiment_db_ctl.examine(file,
use_repository)
return description[class_name]["arginfo"]

async def open_file(self, file):
description = await self.experiment_db_ctl.examine(file, False)
for class_name, class_desc in description.items():
expurl = "file:{}@{}".format(class_name, file)
self.initialize_submission_arguments(expurl, class_desc["arginfo"])
if expurl in self.open_experiments:
self.open_experiments[expurl].close()
self.open_experiment(expurl)

def save_state(self):
docks = {expname: dock.save_state()
for expname, dock in self.open_experiments.items()}
docks = {expurl: dock.save_state()
for expurl, dock in self.open_experiments.items()}
return {
"scheduling": self.submission_scheduling,
"options": self.submission_options,
@@ -547,6 +582,6 @@ def restore_state(self, state):
self.submission_scheduling = state["scheduling"]
self.submission_options = state["options"]
self.submission_arguments = state["arguments"]
for expname, dock_state in state["docks"].items():
dock = self.open_experiment(expname)
for expurl, dock_state in state["docks"].items():
dock = self.open_experiment(expurl)
dock.restore_state(dock_state)
87 changes: 55 additions & 32 deletions artiq/gui/explorer.py
Original file line number Diff line number Diff line change
@@ -9,17 +9,34 @@
from artiq.gui.models import DictSyncTreeSepModel


class _OpenFileDialog(QtGui.QDialog):
def __init__(self, parent, exp_manager):
QtGui.QDialog.__init__(self, parent=parent)
self.setWindowTitle("Open file outside repository")

grid = QtGui.QGridLayout()
self.setLayout(grid)

grid.addWidget(QtGui.QLabel("Filename:"), 0, 0)
filename = QtGui.QLineEdit()
grid.addWidget(filename, 0, 1)

buttons = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel)
grid.addWidget(buttons, 1, 0, 1, 2)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)

def open_file():
file = filename.text()
asyncio.ensure_future(exp_manager.open_file(file))
self.accepted.connect(open_file)


class Model(DictSyncTreeSepModel):
def __init__(self, init):
self.explorer = None
DictSyncTreeSepModel.__init__(self, "/", ["Experiment"], init)

def __setitem__(self, k, v):
DictSyncTreeSepModel.__setitem__(self, k, v)
# TODO
#if self.explorer is not None and k == self.explorer.selected_key:
# self.explorer.update_selection(k, k)


class ExplorerDock(dockarea.Dock):
def __init__(self, status_bar, exp_manager, d_shortcuts,
@@ -37,43 +54,45 @@ def __init__(self, status_bar, exp_manager, d_shortcuts,
self.el.setHeaderHidden(True)
self.el.setSelectionBehavior(QtGui.QAbstractItemView.SelectItems)
self.addWidget(self.el, 0, 0, colspan=2)
self.el.doubleClicked.connect(self.open_clicked)
self.el.doubleClicked.connect(
partial(self.expname_action, "open_experiment"))

open = QtGui.QPushButton("Open")
open.setIcon(QtGui.QApplication.style().standardIcon(
QtGui.QStyle.SP_DialogOpenButton))
open.setToolTip("Open the selected experiment (Return)")
self.addWidget(open, 1, 0)
open.clicked.connect(self.open_clicked)
open.clicked.connect(
partial(self.expname_action, "open_experiment"))

submit = QtGui.QPushButton("Submit")
submit.setIcon(QtGui.QApplication.style().standardIcon(
QtGui.QStyle.SP_DialogOkButton))
submit.setToolTip("Schedule the selected experiment (Ctrl+Return)")
self.addWidget(submit, 1, 1)
submit.clicked.connect(self.submit_clicked)
submit.clicked.connect(
partial(self.expname_action, "submit"))

self.explist_model = Model(dict())
explist_sub.add_setmodel_callback(self.set_model)

self.el.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
open_action = QtGui.QAction("Open", self.el)
open_action.triggered.connect(self.open_clicked)
open_action.triggered.connect(
partial(self.expname_action, "open_experiment"))
open_action.setShortcut("RETURN")
self.el.addAction(open_action)
submit_action = QtGui.QAction("Submit", self.el)
submit_action.triggered.connect(self.submit_clicked)
submit_action.triggered.connect(
partial(self.expname_action, "submit"))
submit_action.setShortcut("CTRL+RETURN")
self.el.addAction(submit_action)
reqterm_action = QtGui.QAction("Request termination of instances", self.el)
reqterm_action.triggered.connect(self.reqterm_clicked)
reqterm_action.triggered.connect(
partial(self.expname_action, "request_inst_term"))
reqterm_action.setShortcut("CTRL+BACKSPACE")
self.el.addAction(reqterm_action)

sep = QtGui.QAction(self.el)
sep.setSeparator(True)
self.el.addAction(sep)

set_shortcut_menu = QtGui.QMenu()
for i in range(12):
action = QtGui.QAction("F" + str(i+1), self.el)
@@ -83,16 +102,26 @@ def __init__(self, status_bar, exp_manager, d_shortcuts,
set_shortcut_action = QtGui.QAction("Set shortcut", self.el)
set_shortcut_action.setMenu(set_shortcut_menu)
self.el.addAction(set_shortcut_action)
scan_repository_action = QtGui.QAction("(Re)scan repository HEAD",

sep = QtGui.QAction(self.el)
sep.setSeparator(True)
self.el.addAction(sep)

scan_repository_action = QtGui.QAction("Scan repository HEAD",
self.el)
def scan_repository():
asyncio.ensure_future(experiment_db_ctl.scan_repository_async())
self.status_bar.showMessage("Requested repository scan")
scan_repository_action.triggered.connect(scan_repository)
self.el.addAction(scan_repository_action)

open_file_action = QtGui.QAction("Open file outside repository",
self.el)
open_file_action.triggered.connect(
lambda: _OpenFileDialog(self, self.exp_manager).open())
self.el.addAction(open_file_action)

def set_model(self, model):
model.explorer = self
self.explist_model = model
self.el.setModel(model)

@@ -103,22 +132,16 @@ def _get_selected_expname(self):
else:
return None

def open_clicked(self):
expname = self._get_selected_expname()
if expname is not None:
self.exp_manager.open_experiment(expname)

def submit_clicked(self):
expname = self._get_selected_expname()
if expname is not None:
self.exp_manager.submit(expname)

def reqterm_clicked(self):
def expname_action(self, action):
expname = self._get_selected_expname()
if expname is not None:
self.exp_manager.request_inst_term(expname)
action = getattr(self.exp_manager, action)
action("repo:" + expname)

def set_shortcut(self, nr):
expname = self._get_selected_expname()
if expname is not None:
self.d_shortcuts.set_shortcut(nr, expname)
expurl = "repo:" + expname
self.d_shortcuts.set_shortcut(nr, expurl)
self.status_bar.showMessage("Set shortcut F{} to '{}'"
.format(nr+1, expurl))
26 changes: 13 additions & 13 deletions artiq/gui/shortcuts.py
Original file line number Diff line number Diff line change
@@ -71,31 +71,31 @@ def __init__(self, main_window, exp_manager):
shortcut.activated.connect(partial(self._activated, i))

def _activated(self, nr):
expname = self.shortcut_widgets[nr]["label"].text()
if expname:
expurl = self.shortcut_widgets[nr]["label"].text()
if expurl:
try:
self.exp_manager.submit(expname)
self.exp_manager.submit(expurl)
except:
# May happen when experiment has been removed
# from repository/explist
logger.warning("failed to submit experiment %s",
expname, exc_info=True)
expurl, exc_info=True)

def _open_experiment(self, nr):
expname = self.shortcut_widgets[nr]["label"].text()
if expname:
expurl = self.shortcut_widgets[nr]["label"].text()
if expurl:
try:
self.exp_manager.open_experiment(expname)
self.exp_manager.open_experiment(expurl)
except:
# May happen when experiment has been removed
# from repository/explist
logger.warning("failed to open experiment %s",
expname, exc_info=True)
expurl, exc_info=True)

def set_shortcut(self, nr, expname):
def set_shortcut(self, nr, expurl):
widgets = self.shortcut_widgets[nr]
widgets["label"].setText(expname)
if expname:
widgets["label"].setText(expurl)
if expurl:
widgets["clear"].show()
widgets["open"].show()
widgets["submit"].show()
@@ -109,5 +109,5 @@ def save_state(self):
for nr, widgets in self.shortcut_widgets.items()}

def restore_state(self, state):
for nr, expname in state.items():
self.set_shortcut(nr, expname)
for nr, expurl in state.items():
self.set_shortcut(nr, expurl)

0 comments on commit 0da8955

Please sign in to comment.