parser = argparse.ArgumentParser(description="ARTIQ CLI client")

import argparse

import asyncio

import gbulb

from gi.repository import Gtk

from artiq.management.sync_struct import Subscriber

class QueueStoreSyncer:

def __init__(self, queue_store, init):

self.queue_store = queue_store

self.queue_store.clear()

for x in init:

self.append(x)

def _convert(self, x):

rid, run_params, timeout = x

row = [rid, run_params["file"]]

for x in run_params["unit"], run_params["function"], timeout:

row.append("-" if x is None else str(x))

return row

def append(self, x):

self.queue_store.append(self._convert(x))

def insert(self, i, x):

self.queue_store.insert(i, self._convert(x))

def __delitem__(self, key):

del self.queue_store[key]

class SchedulerWindow(Gtk.Window):

def __init__(self):

Gtk.Window.__init__(self, title="Scheduler")

self.queue_store = Gtk.ListStore(int, str, str, str, str)

tree = Gtk.TreeView(self.queue_store)

for i, title in enumerate(["RID", "File", "Unit",

"Function", "Timeout"]):

renderer = Gtk.CellRendererText()

column = Gtk.TreeViewColumn(title, renderer, text=i)

tree.append_column(column)

self.add(tree)

@asyncio.coroutine

def sub_connect(self, host, port):

self.subscriber = Subscriber(self.init_queue_store)

yield from self.subscriber.connect(host, port)

@asyncio.coroutine

def sub_close(self):

yield from self.subscriber.close()

def init_queue_store(self, init):

return QueueStoreSyncer(self.queue_store, init)

def _get_args():

parser = argparse.ArgumentParser(description="ARTIQ GUI client")

parser.add_argument(

"-s", "--server", default="::1",

help="hostname or IP of the master to connect to")

parser.add_argument(

"--port-schedule-control", default=8888, type=int,

help="TCP port to connect to for schedule control")

parser.add_argument(

"--port-schedule-notify", default=8887, type=int,

help="TCP port to connect to for schedule notifications")

return parser.parse_args()

def main():

args = _get_args()

asyncio.set_event_loop_policy(gbulb.GtkEventLoopPolicy())

loop = asyncio.get_event_loop()

try:

win = SchedulerWindow()

win.connect("delete-event", Gtk.main_quit)

win.show_all()

loop.run_until_complete(win.sub_connect(args.server,

args.port_schedule_notify))

try:

loop.run_forever()

finally:

loop.run_until_complete(win.sub_close())

finally:

loop.close()

if __name__ == "__main__":

main()