def notice(self, target, msg):
self.raw("NOTICE %s :%s" % (target, msg))
events.trigger(
'OwnNotice', source=self.me, target=str(target), text=msg,
network=self, window=windows.get_default(self)
)
def hover(self, event):
if self.linking:
self.clear_hover()
hover_iter = get_iter_at_coords(self, event.x, event.y)
if not hover_iter.ends_line():
h_data = get_event_at_iter(self, hover_iter)
h_data.tolink = set()
events.trigger("Hover", h_data)
if h_data.tolink:
buffer = self.get_buffer()
offset = buffer.get_iter_at_line(
hover_iter.get_line()
).get_offset()
for fr, to in h_data.tolink:
fr = buffer.get_iter_at_offset(offset + fr)
to = buffer.get_iter_at_offset(offset + to)
buffer.apply_tag_by_name("link", fr, to)
self.linking.add(
(buffer.create_mark(None, fr),
buffer.create_mark(None, to))
)
self.get_window(
gtk.TEXT_WINDOW_TEXT
).set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
self.get_pointer()
def to_edit_mode(self, widget, event):
if self.label not in self.get_children():
return
if getattr(event, 'button', None) == 3:
c_data = events.data(window=self.win, menu=[])
events.trigger("NickEditMenu", c_data)
if c_data.menu:
menu = gtk.Menu()
for item in menu_from_list(c_data.menu):
menu.append(item)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
else:
entry = gtk.Entry()
entry.set_text(self.label.get_text())
entry.connect('activate', self.nick_change)
entry.connect('focus-out-event', self.to_show_mode)
self.remove(self.label)
self.add(entry)
self.window.set_cursor(None)
entry.show()
entry.grab_focus()
def popup(self, menu):
hover_iter = get_iter_at_coords(self, *self.hover_coords)
menuitems = []
if not hover_iter.ends_line():
c_data = get_event_at_iter(self, hover_iter)
c_data.menu = []
events.trigger("RightClick", c_data)
menuitems = c_data.menu
if not menuitems:
c_data = events.data(menu=[])
events.trigger("MainMenu", c_data)
menuitems = c_data.menu
for child in menu.get_children():
menu.remove(child)
for item in menu_from_list(menuitems):
menu.append(item)
menu.show_all()
def connect(self):
if not self.status:
self.status = CONNECTING
self.source = ui.fork(self.on_dns, socket.getaddrinfo, self.server, self.port, 0, socket.SOCK_STREAM)
events.trigger('Connecting', network=self)
def msg(self, target, msg):
self.raw("PRIVMSG %s :%s" % (target, msg))
events.trigger(
'OwnText', source=self.me, target=str(target), text=msg,
network=self, window=windows.get_default(self)
)
def onClose(e):
nwindows = list(windows.get_with(network=e.window.network))
if isinstance(e.window, windows.ChannelWindow):
cwindows = list(windows.get_with(
network=e.window.network,
wclass=windows.ChannelWindow
))
#if we only have one window for the network, don't bother to part as
# we'll soon be quitting anyway
if len(nwindows) != 1 and irc_script.ischan(e.window.network, e.window.id):
e.window.network.part(e.window.id)
if len(nwindows) == 1:
events.trigger("CloseNetwork", window=e.window, network=e.window.network)
elif isinstance(e.window, windows.StatusWindow) and conf.get('status'):
events.trigger("CloseNetwork", window=e.window, network=e.window.network)
for window in nwindows:
if window != e.window:
window.close()
if len(windows.manager) == 1:
windows.new(windows.StatusWindow, irc.Network(), "status")
def build_urk_menu(self, *args):
data = events.data(menu=[])
events.trigger("MainMenu", data)
menu = self.urk_submenu
for child in menu.get_children():
menu.remove(child)
for item in menu_from_list(data.menu):
menu.append(item)
menu.show_all()
def trigger_start():
events.trigger("Start")
window = windows.manager.get_active()
if not window:
window = windows.new(windows.StatusWindow, irc.Network(), "status")
window.activate()
events.run(command, window, window.network)
def change_nick(network, nick):
if not network.status:
events.trigger(
'Nick',
network=network, window=windows.get_default(network),
source=network.me, target=nick, address='', text=nick
)
network.nicks[0] = nick
network.me = nick
else:
network.raw('NICK :%s' % nick)
def mouseup(self, event):
if not self.get_buffer().get_selection_bounds():
if event.button == 1:
hover_iter = get_iter_at_coords(self, event.x, event.y)
if not hover_iter.ends_line():
c_data = get_event_at_iter(self, hover_iter)
events.trigger("Click", c_data)
if self.is_focus():
self.win.focus()
def setupRaw(e):
if not e.done and e.msg[1] in ('PRIVMSG', 'NOTICE') and \
e.text.startswith('\x01') and e.text.endswith('\x01'):
e_data = events.data(**e.__dict__)
e_data.text = e.text[1:-1]
tokens = e_data.text.split(' ')
e_data.name = tokens[0].upper()
e_data.args = tokens[1:]
if e.msg[1] == 'PRIVMSG':
events.trigger('Ctcp', e_data)
else:
events.trigger('CtcpReply', e_data)
e.done = True
def entered_text(self, ctrl):
#FIXME: move this logic into Window
for line in self.text.splitlines():
if line:
e_data = events.data(
window=self.win, network=self.win.network,
text=line, ctrl=ctrl
)
events.trigger('Input', e_data)
if not e_data.done:
events.run(line, self.win, self.win.network)
self.text = ''
def tab_popup(self, event):
if event.button == 3: # right click
c_data = events.data(window=self.win, menu=[])
events.trigger("WindowMenu", c_data)
c_data.menu += [
None,
("Close", gtk.STOCK_CLOSE, self.win.close),
]
menu = gtk.Menu()
for item in menu_from_list(c_data.menu):
menu.append(item)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
def _delay(event, data, seconds, date, doc_id=None):
db = DB()
core = db.core()
if not doc_id:
doc = {'element': 'sched',
'type': 'at',
'event': dumps(event.elements()),
'data': dumps(data),
'date': date}
doc_id = core.insert(doc)
if seconds > 0:
sleep(float(seconds))
trigger(event, data)
core.remove(doc_id)
def on_connect(self, result, error):
if error:
self.disconnect(error=error[1])
#we should immediately retry if we failed to open the socket and there are hosts left
if self.status == DISCONNECTED and not self.failedlasthost:
windows.get_default(self).write("* Retrying with next available host")
self.connect()
else:
self.source = source = ui.Source()
self.status = INITIALIZING
self.failedhosts[:] = ()
events.trigger('SocketConnect', network=self)
if source.enabled:
self.source = ui.fork(self.on_read, self.socket.recv, 8192)
def setupCtcp(e):
if not e.done:
if e.name == 'ACTION':
e_data = events.data(**e.__dict__)
e_data.text = ' '.join(e.args)
events.trigger('Action', e_data)
e.done = True
e.quiet = True
elif e.name == 'PING':
ctcp_reply(e.network, e.source, e.text)
e.done = True
elif e.name == 'VERSION':
ctcp_reply(e.network, e.source, 'VERSION %s - %s' % (urk.long_version, urk.website))
e.done = True
elif e.name == 'TIME':
ctcp_reply(e.network, e.source, 'TIME %s' % time.asctime())
e.done = True
def _delay(event, data, seconds, date, doc_id=None):
db = DB()
core = db.core()
if not doc_id:
doc = {
'element': 'sched',
'type': 'at',
'event': dumps(event.elements()),
'data': dumps(data),
'date': date
}
doc_id = core.insert(doc)
if seconds > 0:
sleep(float(seconds))
trigger(event, data)
core.remove(doc_id)
def onRightClick(e):
set_target(e)
# nick on this channel
if is_nick(e):
make_nick_menu(e, e._target)
elif is_url(e):
if e._target.startswith('www'):
e._target = 'http://%s' % e._target
def copy_to():
# copy to clipboard
ui.set_clipboard(e._target)
e.menu += [('Copy', copy_to)]
elif is_chan(e):
e.channel = e._target
e.network = e.window.network
events.trigger('ChannelMenu', e)
def click(self, event):
if event.button == 3:
x, y = event.get_coords()
(data,), path, x, y = self.get_path_at_pos(int(x), int(y))
c_data = events.data(window=self.win, data=self[data], menu=[])
events.trigger("ListRightClick", c_data)
if c_data.menu:
menu = gtk.Menu()
for item in menu_from_list(c_data.menu):
menu.append(item)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
elif event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
x, y = event.get_coords()
(data,), path, x, y = self.get_path_at_pos(int(x), int(y))
events.trigger("ListDoubleClick", window=self.win, target=self[data])
def got_msg(self, msg):
pmsg = parse_irc(msg, self.server)
e_data = events.data(
raw=msg,
msg=pmsg,
text=pmsg[-1],
network=self,
window=windows.get_default(self)
)
if "!" in pmsg[0]:
e_data.source, e_data.address = pmsg[0].split('!',1)
else:
e_data.source, e_data.address = pmsg[0], ''
if len(pmsg) > 2:
e_data.target = pmsg[2]
else:
e_data.target = pmsg[-1]
events.trigger('Raw', e_data)
def disconnect(self, error=None):
if self.socket:
self.socket.close()
if self.source:
self.source.unregister()
self.source = None
self.socket = None
self.status = DISCONNECTED
#note: connecting from onDisconnect is probably a Bad Thing
events.trigger('Disconnect', network=self, error=error)
#trigger a nick change if the nick we want is different from the one we
# had.
if self.me != self.nicks[0]:
events.trigger(
'Nick', network=self, window=windows.get_default(self),
source=self.me, target=self.nicks[0], address='',
text=self.nicks[0]
)
self.me = self.nicks[0]
def keypress(self, event):
keychar = (
(gtk.gdk.CONTROL_MASK, '^'),
(gtk.gdk.SHIFT_MASK, '+'),
(gtk.gdk.MOD1_MASK, '!')
)
key = ''
for keymod, char in keychar:
# we make this an int, because otherwise it leaks
if int(event.state) & keymod:
key += char
key += gtk.gdk.keyval_name(event.keyval)
events.trigger('KeyPress', key=key, string=event.string, window=self.win)
if key == "^Return":
self.entered_text(True)
up = gtk.gdk.keyval_from_name("Up")
down = gtk.gdk.keyval_from_name("Down")
tab = gtk.gdk.keyval_from_name("Tab")
return event.keyval in (up, down, tab)
def run(task, inputs=None, outputs=None, fetch=True, status=None, **kwargs):
"""
Run a task with the specified I/O bindings.
:param task: Specification of the task to run.
:type task: dict
:param inputs: Specification of how input objects should be fetched
into the runtime environment of this task.
:type inputs: dict
:param outputs: Specification of what should be done with outputs
of this task.
:type outputs: dict
:param write_script: If ``True`` task scripts will be written to file before
being passed to ``exec``. This improves interactive debugging with
tools such as ``pdb`` at the cost of additional file I/O. Note that
when passed to run *all* tasks will be written to file including
validation and conversion tasks.
:param fetch: If ``True`` will perform a fetch on the input before
running the task (default ``True``).
:param status: Job status to update to during execution of this task.
:type status: girder_worker.utils.JobStatus
:returns: A dictionary of the form ``name: binding`` where ``name`` is
the name of the output and ``binding`` is an output binding of the form
``{'data': data}``. The ``'data'`` field may be absent if an output URI
was provided. Instead, those outputs will be saved to that URI and the
output binding will contain the location in the ``'uri'`` field.
"""
inputs = inputs or {}
outputs = outputs or {}
task_inputs = {_extractId(d): d for d in task.get('inputs', ())}
task_outputs = {_extractId(d): d for d in task.get('outputs', ())}
mode = task.get('mode', 'python')
if mode not in _task_map:
raise Exception('Invalid mode: %s' % mode)
job_mgr = kwargs.get('_job_manager')
info = {
'task': task,
'task_inputs': task_inputs,
'task_outputs': task_outputs,
'mode': mode,
'inputs': inputs,
'outputs': outputs,
'status': status,
'job_mgr': job_mgr,
'kwargs': kwargs
}
events.trigger('run.before', info)
try:
# If some inputs are not there, fill in with defaults
_validateInputs(task_inputs, inputs)
for name, d in inputs.iteritems():
task_input = task_inputs[name]
if task_input.get('stream'):
continue # this input will be fetched as a stream
if fetch:
if status == JobStatus.RUNNING and 'data' not in d:
set_job_status(job_mgr, JobStatus.FETCHING_INPUT)
d['data'] = io.fetch(d, **dict({'task_input': task_input}, **kwargs))
events.trigger('run.handle_input', {
'info': info,
'task_input': task_input,
'input': d,
'name': name
})
if 'script_data' not in d:
d['script_data'] = d['data']
for name, task_output in task_outputs.iteritems():
if name not in outputs:
outputs[name] = {}
# Set the appropriate job status flag
set_job_status(job_mgr, status)
# Actually run the task for the given mode
_task_map[mode](
task=task, inputs=inputs, outputs=outputs, task_inputs=task_inputs,
task_outputs=task_outputs, **kwargs)
for name, task_output in task_outputs.iteritems():
if task_output.get('stream'):
continue # this output has already been sent as a stream
output = outputs[name]
e = events.trigger('run.handle_output', {
'info': info,
'task_output': task_output,
'output': output,
'outputs': outputs,
'name': name
})
if not e.default_prevented:
data = outputs[name]['script_data']
if status == JobStatus.RUNNING:
set_job_status(job_mgr, JobStatus.PUSHING_OUTPUT)
io.push(data, outputs[name], **dict({'task_output': task_output}, **kwargs))
output.pop('script_data', None)
events.trigger('run.after', info)
return outputs
except StateTransitionException:
if job_mgr:
status = job_mgr.refreshStatus()
# If we are canceling we want to stay in that state, otherwise raise
# the exception
if status != JobStatus.CANCELING:
raise
else:
raise
finally:
events.trigger('run.finally', info)
def run(task, inputs=None, outputs=None, auto_convert=True, validate=True,
fetch=True, status=None, **kwargs):
"""
Run a task with the specified I/O bindings.
:param task: Specification of the task to run.
:type task: dict
:param inputs: Specification of how input objects should be fetched
into the runtime environment of this task.
:type inputs: dict
:param outputs: Speficiation of what should be done with outputs
of this task.
:type outputs: dict
:param auto_convert: If ``True`` (the default), perform format conversions
on inputs and outputs with :py:func:`convert` if they do not
match the formats specified in the input and output bindings.
If ``False``, an expection is raised for input or output bindings
do not match the formats specified in the analysis.
:param validate: If ``True`` (the default), perform input and output
validation with :py:func:`isvalid` to ensure input bindings are in the
appropriate format and outputs generated by the script are
formatted correctly. This guards against dirty input as well as
buggy scripts that do not produce the correct type of output. An
invalid input or output will raise an exception. If ``False``, perform
no validation.
:param write_script: If ``True`` task scripts will be written to file before
being passed to ``exec``. This improves interactive debugging with
tools such as ``pdb`` at the cost of additional file I/O. Note that
when passed to run *all* tasks will be written to file including
validation and conversion tasks.
:param fetch: If ``True`` will perform a fetch on the input before
running the task (default ``True``).
:param status: Job status to update to during execution of this task.
:type status: girder_worker.utils.JobStatus
:returns: A dictionary of the form ``name: binding`` where ``name`` is
the name of the output and ``binding`` is an output binding of the form
``{'format': format, 'data': data}``. If the `outputs` param
is specified, the formats of these bindings will match those given in
`outputs`. Additionally, ``'data'`` may be absent if an output URI
was provided. Instead, those outputs will be saved to that URI and
the output binding will contain the location in the ``'uri'`` field.
"""
def extractId(spec):
return spec['id'] if 'id' in spec else spec['name']
if inputs is None:
inputs = {}
task_inputs = {extractId(d): d for d in task.get('inputs', ())}
task_outputs = {extractId(d): d for d in task.get('outputs', ())}
mode = task.get('mode', 'python')
if mode not in _task_map:
raise Exception('Invalid mode: %s' % mode)
job_mgr = kwargs.get('_job_manager')
info = {
'task': task,
'task_inputs': task_inputs,
'task_outputs': task_outputs,
'mode': mode,
'inputs': inputs,
'outputs': outputs,
'auto_convert': auto_convert,
'validate': validate,
'kwargs': kwargs
}
events.trigger('run.before', info)
try:
# If some inputs are not there, fill in with defaults
for name, task_input in task_inputs.iteritems():
if name not in inputs:
if 'default' in task_input:
inputs[name] = task_input['default']
else:
raise Exception(
'Required input \'%s\' not provided.' % name)
for name, d in inputs.iteritems():
task_input = task_inputs[name]
if task_input.get('stream'):
continue # this input will be fetched as a stream
# Fetch the input
if fetch:
if status == JobStatus.RUNNING and 'data' not in d:
_job_status(job_mgr, JobStatus.FETCHING_INPUT)
d['data'] = io.fetch(
d, **dict({'task_input': task_input}, **kwargs))
# Validate the input
if validate and not isvalid(
task_input['type'], d,
**dict(
{'task_input': task_input, 'fetch': False}, **kwargs)):
raise Exception(
'Input %s (Python type %s) is not in the expected type '
'(%s) and format (%s).' % (
name, type(d['data']), task_input['type'], d['format'])
)
# Convert data
if auto_convert:
try:
converted = convert(
task_input['type'], d, {'format': task_input['format']},
status=JobStatus.CONVERTING_INPUT,
**dict(
{'task_input': task_input, 'fetch': False},
**kwargs))
except Exception, e:
raise Exception('%s: %s' % (name, str(e)))
d['script_data'] = converted['data']
elif not validate or (d.get('format', task_input.get('format')) ==
task_input.get('format')):
d['script_data'] = d['data']
else:
d['format'])
)
# We should consider refactoring the logic below, reasoning about
# the paths through this code is difficult, since this logic is
# entered by 'run', 'isvalid', and 'convert'.
if auto_convert:
outputs[name] = convert(
task_output['type'], script_output, d,
status=JobStatus.CONVERTING_OUTPUT,
**dict({'task_output': task_output}, **kwargs))
elif not validate or d['format'] == task_output['format']:
data = d['script_data']
if status == JobStatus.RUNNING:
_job_status(job_mgr, JobStatus.PUSHING_OUTPUT)
io.push(
data, d, **dict({'task_output': task_output}, **kwargs))
else:
raise Exception('Expected exact format match but %s != %s.' % (
d['format'], task_output['format']))
if 'script_data' in outputs[name]:
del outputs[name]['script_data']
events.trigger('run.after', info)
return outputs
finally:
events.trigger('run.finally', info)
def raw(self, msg):
events.trigger("OwnRaw", network=self, raw=msg)
if self.status >= INITIALIZING:
self.socket.send(msg + "\r\n")
def onWindowMenu(e):
if isinstance(e.window, windows.ChannelWindow):
e.channel = e.window.id
e.network = e.window.network
events.trigger('ChannelMenu', e)
def emote(network, user, msg):
network.raw("PRIVMSG %s :\x01ACTION %s\x01" % (user, msg))
events.trigger(
'OwnAction', network=network, window=windows.get_default(network),
source=network.me, target=str(user), text=msg
)
def window_change(notebook, _wptr, page_num):
events.trigger("Active", window=notebook.get_nth_page(page_num))
def super_window_change(self, event):
if event.type == gtk.gdk.FOCUS_CHANGE and event.in_:
window = windows.manager.get_active()
if window:
events.trigger('SuperActive', window=window)
def exit(self, *args):
events.trigger("Exit")
gtk.main_level() and gtk.main_quit()
