def _connect(self, obj_1_id, obj_1_port, obj_2_id, obj_2_port):
from .gui_main import MFPGUI
from .gui.connection_element import ConnectionElement
from .gui.patch_info import PatchInfo
from mfp import log
obj_1 = MFPGUI().recall(obj_1_id)
obj_2 = MFPGUI().recall(obj_2_id)
if obj_1 is None or obj_2 is None:
log.debug("ERROR: connect: obj_1 (id=%s) --> %s, obj_2 (id=%s) --> %s"
% (obj_1_id, obj_1, obj_2_id, obj_2))
return None
elif isinstance(obj_1, PatchInfo) or isinstance(obj_2, PatchInfo):
log.debug("Trying to connect a PatchInfo (%s [%s] --> %s [%s])"
% (obj_1.obj_name, obj_1_id, obj_2.obj_name, obj_2_id))
return None
for conn in obj_1.connections_out:
if conn.obj_2 == obj_2 and conn.port_2 == obj_2_port:
return
c = ConnectionElement(MFPGUI().appwin, obj_1, obj_1_port, obj_2, obj_2_port)
MFPGUI().appwin.register(c)
obj_1.connections_out.append(c)
obj_2.connections_in.append(c)
def _grab(self):
def offset(channel):
return channel * self.buf_info.size * self.FLOAT_SIZE
if self.buf_info is None:
return None
if self.shm_obj is None:
self.shm_obj = SharedMemory(self.buf_info.buf_id)
self.data = []
try:
for c in range(self.buf_info.channels):
os.lseek(self.shm_obj.fd, offset(c), os.SEEK_SET)
slc = os.read(self.shm_obj.fd,
int(self.buf_info.size * self.FLOAT_SIZE))
self.data.append(
list(numpy.fromstring(slc, dtype=numpy.float32)))
self.set_bounds(0, None,
len(self.data[0]) * 1000 / self.samplerate,
None)
except Exception, e:
log.debug("scopeplot: error grabbing data", e)
import traceback
traceback.print_exc()
return None
def run(self):
from mfp import log
# create socket
try:
os.unlink(self.socketpath)
except OSError:
if os.path.exists(self.socketpath):
raise
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# set up to accept connections
self.socket.bind(self.socketpath)
self.socket.listen(5)
self.socket.settimeout(1)
# accept connections until told to stop
while not self.join_req:
try:
sock, addr = self.socket.accept()
log.debug("accept: got", sock, addr)
sock.settimeout(0.25)
self._rpc_last_peer += 1
newpeer = self._rpc_last_peer
self.rpc_host.manage(newpeer, sock)
except socket.timeout:
pass
def run(self):
from mfp import log
# create socket
try:
os.unlink(self.socketpath)
except OSError:
if os.path.exists(self.socketpath):
raise
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# set up to accept connections
self.socket.bind(self.socketpath)
self.socket.listen(5)
self.socket.settimeout(1)
# accept connections until told to stop
while not self.join_req:
try:
sock, addr = self.socket.accept()
log.debug("accept: got", sock, addr)
sock.settimeout(0.25)
self._rpc_last_peer += 1
newpeer = self._rpc_last_peer
self.rpc_host.manage(newpeer, sock)
except socket.timeout:
pass
def handler(stage, event):
try:
return self.input_mgr.handle_event(stage, event)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def handler(stage, event):
try:
return self.input_mgr.handle_event(stage, event)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def save_lv2(self, plugname, filename):
import os.path
log.debug("save_lv2: %s, %s" % (plugname, filename))
plugpath = self.lv2_create_dir(plugname)
ttlpath = os.path.join(plugpath, "manifest.ttl")
self.lv2_write_ttl(ttlpath, plugname, filename)
patchpath = os.path.join(plugpath, filename)
self.save_file(patchpath)
def _callback_wrapper(self, thunk):
try:
return thunk()
except Exception as e:
import traceback
log.debug("Exception in GUI operation:", e)
log.debug_traceback()
return False
def _callback_wrapper(self, thunk):
try:
return thunk()
except Exception as e:
import traceback
log.debug("Exception in GUI operation:", e)
log.debug_traceback()
return False
def start(self):
from mfp import log
import subprocess
arglist = [self.exec_file] + self.exec_args
log.debug("RPCExecRemote: starting as ", arglist)
self.process = subprocess.Popen([str(a) for a in arglist], bufsize=0,
stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
QuittableThread.start(self)
def save_lv2(self, plugname, filename):
import os.path
log.debug("save_lv2: %s, %s" % (plugname, filename))
plugpath = self.lv2_create_dir(plugname)
ttlpath = os.path.join(plugpath, "manifest.ttl")
self.lv2_write_ttl(ttlpath, plugname, filename)
patchpath = os.path.join(plugpath, filename)
self.save_file(patchpath)
def load_complete(self):
self.load_in_progress = False
if self.selected_patch is None and len(self.patches):
self.selected_patch = self.patches[0]
if self.selected_layer is None and self.selected_patch is not None:
self.layer_select(self.selected_patch.layers[0])
self.object_view.refresh()
self.layer_view.refresh()
log.debug("Patch GUI completed")
def command(self, action, data):
if action == "buffer":
log.debug("scopeplot: got buffer info", data)
self.buf_info = data
self.shm_obj = None
elif action == "grab":
self._grab()
self.plot.invalidate()
return True
def command(self, action, data):
if action == "buffer":
log.debug("scopeplot: got buffer info", data)
self.buf_info = data
self.shm_obj = None
elif action == "grab":
self._grab()
self.plot.invalidate()
return True
def start(self):
from mfp import log
import subprocess
arglist = [self.exec_file] + self.exec_args
log.debug("RPCExecRemote: starting as ", arglist)
self.process = subprocess.Popen([str(a) for a in arglist],
bufsize=0,
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE)
QuittableThread.start(self)
def patch_close(self):
p = self.selected_patch
if p and p.deletable:
self.patch_select_next()
self.patches.remove(p)
p.delete()
else:
log.debug("Cannot close window. Close UI via plugin host Edit button")
if not len(self.patches):
self.quit()
def label_edit_finish(self, widget, new_text, aborted=False):
if self.obj_id is None:
self.create(self.proc_type, None)
if self.obj_id is None:
log.debug("TextElement: could not create obj")
elif new_text != self.value:
self.value = new_text
self.label.set_markup(self.value)
MFPGUI().mfp.send(self.obj_id, 0, self.value)
self.update()
def label_edit_finish(self, widget, new_text, aborted=False):
if self.obj_id is None:
self.create(self.proc_type, None)
if self.obj_id is None:
log.debug("TextElement: could not create obj")
elif new_text != self.value:
self.value = new_text
self.label.set_markup(self.value)
MFPGUI().mfp.send(self.obj_id, 0, self.value)
self.update()
def patch_close(self):
p = self.selected_patch
if p and p.deletable:
self.patch_select_next()
self.patches.remove(p)
p.delete()
else:
log.debug("Cannot close window. Close UI via plugin host Edit button")
if not len(self.patches):
self.quit()
def __init__(self, init_type, init_args, patch, scope, name):
self.buffer = None
self.retrig_value = True
self.need_buffer_send = False
if init_args is not None:
log.debug("scope: Does not accept init args")
self.gui_params = dict(plot_type="scope")
Processor.__init__(self, 1, 1, init_type, init_args, patch, scope, name)
def grab_handler(stage, event):
try:
if not self.embed.has_focus():
self.embed.grab_focus()
return self.input_mgr.handle_event(stage, event)
except Exception, e:
import traceback
log.error("Error handling UI event", event)
log.debug(e)
traceback.print_exc()
return False
def __init__(self, init_type, init_args, patch, scope, name):
self.buffer = None
self.retrig_value = True
self.need_buffer_send = False
if init_args is not None:
log.debug("scope: Does not accept init args")
self.gui_params = dict(plot_type="scope")
Processor.__init__(self, 1, 1, init_type, init_args, patch, scope,
name)
def trigger(self):
if isinstance(self.inlets[0], dict):
for param, val in self.inlets[0].items():
try:
self.dsp_setparam(param, float(val))
except Exception, e:
import traceback
tb = traceback.format_exc()
log.debug("ampl~: Error setting param", param, "to", type(val), str(val))
log.debug("ampl~: Exception:", str(e))
self.error(tb)
def trigger(self):
if isinstance(self.inlets[0], dict):
for param, val in self.inlets[0].items():
try:
self.dsp_setparam(param, float(val))
except Exception as e:
import traceback
tb = traceback.format_exc()
log.debug("ampl~: Error setting param", param, "to", type(val), str(val))
log.debug("ampl~: Exception:", str(e))
self.error(tb)
def set_scope(self, obj_id, scope_name):
from .mfp_app import MFPApp
obj = MFPApp().recall(obj_id)
if obj is None or isinstance(obj, MFPApp):
log.debug("Cannot find object for %s to set scope to %s" % (obj_id, scope_name))
return
scope = obj.patch.scopes.get(scope_name)
if scope is None:
scope = obj.patch.add_scope(scope_name)
obj.assign(obj.patch, scope, obj.name)
def set_scope(self, obj_id, scope_name):
from .mfp_app import MFPApp
obj = MFPApp().recall(obj_id)
if obj is None or isinstance(obj, MFPApp):
log.debug("Cannot find object for %s to set scope to %s" %
(obj_id, scope_name))
return
scope = obj.patch.scopes.get(scope_name)
if scope is None:
scope = obj.patch.add_scope(scope_name)
obj.assign(obj.patch, scope, obj.name)
def layer_scope_edited(layer, new_value):
from mfp import log
if isinstance(layer, Layer):
p = self.selected_patch
if not p.has_scope(new_value):
log.debug("Adding scope", new_value, "to patch", self.selected_patch)
MFPCommand().add_scope(self.selected_patch.obj_id, new_value)
layer.scope = new_value
self.selected_patch.send_params()
for obj in self.objects:
if obj.obj_id is not None and obj.layer == layer:
MFPCommand().set_scope(obj.obj_id, new_value)
self.refresh(obj)
return True
def patch_close(self):
def close_confirm(answer):
if answer is not None:
aa = answer.strip().lower()
if aa in ['y', 'yes']:
self.window.patch_close()
from mfp import log
p = self.window.selected_patch
log.debug("patch_close: checking for unsaved changes")
if MFPGUI().mfp.has_unsaved_changes(p.obj_id):
self.window.get_prompted_input("Patch has unsaved changes. Close anyway? [yN]",
close_confirm, '')
else:
self.window.patch_close()
def call_remotely(self, rpcdata, response=True):
from datetime import datetime
r = Request("call", rpcdata)
call_started = datetime.now()
r.diagnostic["remote_call_start"] = str(call_started)
if not response:
r.request_id = None
try:
self.rpchost.put(r, self.peer_id)
except Exception as e:
if self.rpchost:
log.debug("[call_remotely] Error in RPC operation:", e)
log.debug_traceback()
return None
puttime = str(datetime.now())
if response:
self.rpchost.wait(r, timeout=10)
call_complete = datetime.now()
call_elapsed = call_complete - call_started
r.diagnostic["remote_call_complete"] = call_complete
r.diagnostic["remote_call_put"] = puttime
callinfo = self.call_stats.setdefault(rpcdata.get('func'), {})
total = callinfo.get("total")
if total:
total += call_elapsed
else:
total = call_elapsed
callinfo["total"] = total
count = callinfo.get("count", 0) + 1
callinfo["count"] = count
callinfo["avgtime"] = total / count
if not response:
return None
elif not r.result:
print "FIXME: no result should return a deferment"
return None
status, retval = r.result
if status == RPCWrapper.METHOD_OK:
return retval
elif status == RPCWrapper.METHOD_FAILED:
raise RPCWrapper.MethodFailed(False, retval)
def register_file(klass, filename):
from .mfp_app import MFPApp
def factory(init_type, init_args, patch, scope, name, context=None):
p = Patch(init_type, init_args, patch, scope, name, context)
p._load_file(filename)
p.init_type = init_type
return p
basefile = os.path.basename(filename)
parts = os.path.splitext(basefile)
log.debug("Patch.register_file: registering type '%s' from file '%s'"
% (parts[0], filename))
MFPApp().register(parts[0], factory)
return (parts[0], factory)
def register_file(klass, filename):
from .mfp_app import MFPApp
def factory(init_type, init_args, patch, scope, name, context=None):
p = Patch(init_type, init_args, patch, scope, name, context)
p._load_file(filename)
p.init_type = init_type
return p
basefile = os.path.basename(filename)
parts = os.path.splitext(basefile)
log.debug("Patch.register_file: registering type '%s' from file '%s'" %
(parts[0], filename))
MFPApp().register(parts[0], factory)
return (parts[0], factory)
def patch_close(self):
def close_confirm(answer):
if answer is not None:
aa = answer.strip().lower()
if aa in ['y', 'yes']:
self.window.patch_close()
from mfp import log
p = self.window.selected_patch
log.debug("patch_close: checking for unsaved changes")
if MFPGUI().mfp.has_unsaved_changes(p.obj_id):
self.window.get_prompted_input(
"Patch has unsaved changes. Close anyway? [yN]", close_confirm,
'')
else:
self.window.patch_close()
def layer_scope_edited(layer, new_value):
from mfp import log
if isinstance(layer, Layer):
p = self.selected_patch
if not p.has_scope(new_value):
log.debug("Adding scope", new_value, "to patch",
self.selected_patch)
MFPCommand().add_scope(self.selected_patch.obj_id, new_value)
layer.scope = new_value
self.selected_patch.send_params()
for obj in self.objects:
if obj.obj_id is not None and obj.layer == layer:
MFPCommand().set_scope(obj.obj_id, new_value)
self.refresh(obj)
return True
def obj_selected(obj):
self._select(obj)
if isinstance(obj, PatchElement):
self.layer_select(obj.layer)
elif isinstance(obj, PatchInfo):
self.layer_select(obj.layers[0])
elif isinstance(obj, tuple):
scope = obj[0]
patch = obj[1]
if isinstance(patch, PatchInfo):
for l in patch.layers:
if l.scope == scope:
self.layer_select(l)
return
self.layer_select(patch.layers[0])
else:
log.debug("[obj_selected] Got tuple", obj)
self.layer_select(patch.layer)
def autoplace_noselection(self):
width, height = self.window.stage.get_size()
spacing = self.NONE_SPACING
cols = int(width / spacing)
rows = int(height / spacing)
if self.placement > rows * cols:
self.placement = 0
log.debug(self.placement, width, cols, height, rows)
x = self.X_OFF + (self.placement % cols) * spacing
y = self.Y_OFF + int(self.placement / cols) * spacing
self._set_autoplace(x, y)
self.placement += 1
return True
def autoplace_noselection(self):
width, height = self.window.stage.get_size()
spacing = self.NONE_SPACING
cols = int(width / spacing)
rows = int(height / spacing)
if self.placement > rows * cols:
self.placement = 0
log.debug(self.placement, width, cols, height, rows)
x = self.X_OFF + (self.placement % cols) * spacing
y = self.Y_OFF + int(self.placement / cols) * spacing
self._set_autoplace(x, y)
self.placement += 1
return True
def trigger(self):
if isinstance(self.inlets[0], BufferInfo):
self.buffer = self.inlets[0]
if self.gui_created:
MFPApp().gui_command.command(self.obj_id, "buffer", self.buffer)
else:
self.need_buffer_send = True
elif self.inlets[0] is True:
pass
elif self.inlets[0] is False:
if self.gui_created:
self.grab()
if self.buffer is None:
log.debug("scope: got input from buffer, but no bufferinfo.. requesting")
self.outlets[0] = MethodCall("bufinfo")
if self.gui_created and self.need_buffer_send:
self.need_buffer_send = False
MFPApp().gui_command.command(self.obj_id, "buffer", self.buffer)
def _resize_cb(self, widget, rect):
try:
self.stage.set_size(rect.width, rect.height)
if self.hud_mode_txt:
self.hud_mode_txt.set_position(self.stage.get_width()-80,
self.stage.get_height()-25)
if self.hud_prompt:
self.hud_prompt.set_position(10, self.stage.get_height() - 25)
if self.hud_prompt_input:
self.hud_prompt_input.set_position(15 + self.hud_prompt.get_width(),
self.stage.get_height() - 25)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def open_context(self, node_id, context_id, owner_pid, samplerate):
from .dsp_object import DSPContext
from .mfp_app import MFPApp
try:
ctxt_name = open("/proc/%d/cmdline" % owner_pid,
"r").read().split("\x00")[0]
log.debug("open_context: new context, name=%s" % ctxt_name)
except:
ctxt_name = ""
if MFPApp().samplerate != samplerate:
log.debug("open_context: samplerate changing from %d to %d" %
(MFPApp().samplerate, samplerate))
MFPApp().samplerate = samplerate
if DSPContext.create(node_id, context_id, ctxt_name):
return True
else:
return False
def open_context(self, node_id, context_id, owner_pid, samplerate):
from .dsp_object import DSPContext
from .mfp_app import MFPApp
try:
ctxt_name = open("/proc/%d/cmdline" % owner_pid, "r").read().split("\x00")[0]
log.debug("open_context: new context, name=%s" % ctxt_name)
except:
ctxt_name = ""
if MFPApp().samplerate != samplerate:
log.debug("open_context: samplerate changing from %d to %d" %
(MFPApp().samplerate, samplerate))
MFPApp().samplerate = samplerate
if DSPContext.create(node_id, context_id, ctxt_name):
return True
else:
return False
def _resize_cb(self, widget, rect):
try:
self.stage.set_size(rect.width, rect.height)
if self.hud_mode_txt:
self.hud_mode_txt.set_position(self.stage.get_width() - 80,
self.stage.get_height() - 25)
if self.hud_prompt:
self.hud_prompt.set_position(10, self.stage.get_height() - 25)
if self.hud_prompt_input:
self.hud_prompt_input.set_position(
15 + self.hud_prompt.get_width(),
self.stage.get_height() - 25)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def run(self):
work = []
retry = []
while not self.join_req:
with self.lock:
self.cv.wait(0.25)
work = []
if self.queue:
work.extend(self.queue)
self.queue = []
if self.failed:
toonew = []
newest = datetime.utcnow() - timedelta(milliseconds=250)
for jobs, timestamp in self.failed:
if timestamp < newest:
work.extend(jobs)
else:
toonew.append((jobs, timestamp))
self.failed = toonew
retry = []
for unit, retry_count, data in work:
try:
done = unit(*data)
except Exception as e:
log.debug("Exception while running", unit)
log.debug_traceback()
if not done and retry_count:
if isinstance(retry_count, (int, float)):
if retry_count > 1:
retry_count -= 1
else:
log.warning("[TaskNibbler] ran out of retries for", unit, data)
retry_count = False
retry.append((unit, retry_count, data))
if retry:
with self.lock:
self.failed.append((retry, datetime.utcnow()))
def run(self):
work = []
retry = []
while not self.join_req:
with self.lock:
self.cv.wait(0.25)
work = []
if self.queue:
work.extend(self.queue)
self.queue = []
if self.failed:
toonew = []
newest = datetime.utcnow() - timedelta(milliseconds=250)
for jobs, timestamp in self.failed:
if timestamp < newest:
work.extend(jobs)
else:
toonew.append((jobs, timestamp))
self.failed = toonew
retry = []
for unit, retry_count, data in work:
try:
done = unit(*data)
except Exception as e:
log.debug("Exception while running", unit)
log.debug_traceback()
if not done and retry_count:
if isinstance(retry_count, (int, float)):
if retry_count > 1:
retry_count -= 1
else:
log.warning("[TaskNibbler] ran out of retries for", unit, data)
retry_count = False
retry.append((unit, retry_count, data))
if retry:
with self.lock:
self.failed.append((retry, datetime.utcnow()))
def _grab(self):
def offset(channel):
return channel * self.buf_info.size * self.FLOAT_SIZE
if self.buf_info is None:
return None
if self.shm_obj is None:
self.shm_obj = SharedMemory(self.buf_info.buf_id)
self.data = []
try:
for c in range(self.buf_info.channels):
os.lseek(self.shm_obj.fd, offset(c), os.SEEK_SET)
slc = os.read(self.shm_obj.fd, int(self.buf_info.size * self.FLOAT_SIZE))
self.data.append(list(numpy.fromstring(slc, dtype=numpy.float32)))
self.set_bounds(0, None, len(self.data[0])*1000/self.samplerate, None)
except Exception as e:
log.debug("scopeplot: error grabbing data", e)
import traceback
traceback.print_exc()
return None
def trigger(self):
if isinstance(self.inlets[0], BufferInfo):
self.buffer = self.inlets[0]
if self.gui_created:
MFPApp().gui_command.command(self.obj_id, "buffer",
self.buffer)
else:
self.need_buffer_send = True
elif self.inlets[0] is True:
pass
elif self.inlets[0] is False:
if self.gui_created:
self.grab()
if self.buffer is None:
log.debug(
"scope: got input from buffer, but no bufferinfo.. requesting")
self.outlets[0] = MethodCall("bufinfo")
if self.gui_created and self.need_buffer_send:
self.need_buffer_send = False
MFPApp().gui_command.command(self.obj_id, "buffer", self.buffer)
def label_edit_finish(self, *args):
t = self.label.get_text()
if t != self.label_text:
parts = t.split(' ', 1)
self.obj_type = parts[0]
if len(parts) > 1:
self.obj_args = parts[1]
log.debug("PlotElement: type=%s, args=%s" % (self.obj_type, self.obj_args))
self.proc_type = self.obj_type
self.create(self.proc_type, self.obj_args)
if self.obj_id is None:
log.debug("PlotElement: could not create", self.obj_type, self.obj_args)
else:
self.send_params()
self.draw_ports()
# FIXME set label to non-editing style
self.update()
def quit(self, *rest):
from .patch_info import PatchInfo
log.debug("Quit command from GUI or WM")
self.close_in_progress = True
to_delete = [ p for p in self.patches if p.deletable ]
for p in to_delete:
p.delete()
self.close_in_progress = False
self.object_view.refresh()
allpatches = MFPGUI().mfp.open_patches()
guipatches = [ p.obj_id for p in self.objects if isinstance(p, PatchInfo) ]
for a in allpatches:
if a not in guipatches:
log.debug("Some patches cannot be deleted, not quitting")
return False
if self.console_mgr:
self.console_mgr.quitreq = True
self.console_mgr.join()
log.debug("Console thread reaped")
self.console_mgr = None
MFPGUI().appwin = False
MFPGUI().finish()
MFPGUI().mfp.quit()
return True
def quit(self, *rest):
from .patch_info import PatchInfo
log.debug("Quit command from GUI or WM")
self.close_in_progress = True
to_delete = [ p for p in self.patches if p.deletable ]
for p in to_delete:
p.delete()
self.close_in_progress = False
self.object_view.refresh()
allpatches = MFPGUI().mfp.open_patches()
guipatches = [ p.obj_id for p in self.objects if isinstance(p, PatchInfo) ]
for a in allpatches:
if a not in guipatches:
log.debug("Some patches cannot be deleted, not quitting")
return False
if self.console_mgr:
self.console_mgr.quitreq = True
self.console_mgr.join()
log.debug("Console thread reaped")
self.console_mgr = None
MFPGUI().appwin = False
MFPGUI().finish()
MFPGUI().mfp.quit()
return True
def call(self, target):
try:
m = getattr(target, self.method)
except AttributeError as e:
raise MethodCallError("Method '%s' not found for type '%s'" %
(self.method, target.init_type))
if callable(m):
try:
return m(*self.args, **self.kwargs)
except Exception as e:
log.debug("Error calling", self.method, "on", target)
log.debug("args=%s, kwargs=%s" % (self.args, self.kwargs))
log.debug_traceback()
raise MethodCallError(
"Method '%s' for type '%s' raised exception '%s' %s" %
(self.method, target.init_type, e, type(e)))
elif self.fallback:
try:
return self.fallback([self] + self.args, **self.kwargs)
except Exception as e:
raise MethodCallError(
"Method fallback '%s' for type '%s' raised exception '%s'"
% (self.method, target.init_type, e))
else:
log.debug("MethodCall.call():", target, self.method, m, type(m))
raise MethodCallError("Method '%s' of type '%s' cannot be called" %
(self.method, target.init_type))
def call(self, target):
try:
m = getattr(target, self.method)
except AttributeError as e:
raise MethodCallError("Method '%s' not found for type '%s'" % (self.method, target.init_type))
if callable(m):
try:
return m(*self.args, **self.kwargs)
except Exception as e:
log.debug("Error calling", self.method, "on", target)
log.debug( "args=%s, kwargs=%s" % (self.args, self.kwargs))
log.debug_traceback()
raise MethodCallError("Method '%s' for type '%s' raised exception '%s' %s"
% (self.method, target.init_type, e, type(e)))
elif self.fallback:
try:
return self.fallback([self] + self.args, **self.kwargs)
except Exception as e:
raise MethodCallError("Method fallback '%s' for type '%s' raised exception '%s'"
% (self.method, target.init_type, e))
else:
log.debug("MethodCall.call():", target, self.method, m, type(m))
raise MethodCallError("Method '%s' of type '%s' cannot be called"
% (self.method, target.init_type))
def make_connection(self):
# are both ends selected?
if self.reverse and self.source_obj is None and self.window.selected:
self.source_obj = self.window.selected[0]
if not self.reverse and self.dest_obj is None and self.window.selected:
self.dest_obj = self.window.selected[0]
if (self.source_obj and self.dest_obj
and self.connection.obj_state != PatchElement.OBJ_DELETED):
if MFPGUI().mfp.connect(self.source_obj.obj_id, self.source_port,
self.dest_obj.obj_id, self.dest_port):
c = ConnectionElement(self.window, self.source_obj, self.source_port,
self.dest_obj, self.dest_port)
MFPGUI().appwin.register(c)
self.source_obj.connections_out.append(c)
self.dest_obj.connections_in.append(c)
else:
log.debug("ConnectionMode: Cannot make connection")
self.manager.disable_minor_mode(self)
return True
def make_connection(self):
# are both ends selected?
if self.reverse and self.source_obj is None and self.window.selected:
self.source_obj = self.window.selected[0]
if not self.reverse and self.dest_obj is None and self.window.selected:
self.dest_obj = self.window.selected[0]
if (self.source_obj and self.dest_obj
and self.connection.obj_state != PatchElement.OBJ_DELETED):
if MFPGUI().mfp.connect(self.source_obj.obj_id, self.source_port,
self.dest_obj.obj_id, self.dest_port):
c = ConnectionElement(self.window, self.source_obj,
self.source_port, self.dest_obj,
self.dest_port)
MFPGUI().appwin.register(c)
self.source_obj.connections_out.append(c)
self.dest_obj.connections_in.append(c)
else:
log.debug("ConnectionMode: Cannot make connection")
self.manager.disable_minor_mode(self)
return True
def slice(self, start, end, channel=0):
if self.shm_obj is None:
self.shm_obj = SharedMemory(self.buf_id)
if start < 0:
start = 0
if start >= self.size:
start = self.size-1
if end < 0:
end = 0
if end >= self.size:
end = self.size-1
try:
os.lseek(self.shm_obj.fd, self.offset(channel, start), os.SEEK_SET)
slc = os.read(self.shm_obj.fd, (end - start) * self.FLOAT_SIZE)
self.outlets[1] = list(numpy.fromstring(slc, dtype=numpy.float32))
except Exception as e:
import traceback
tb = traceback.format_exc()
log.debug("buffer~: slice error '%s" % e)
self.error(tb)
return None
def slice(self, start, end, channel=0):
if self.shm_obj is None:
self.shm_obj = SharedMemory(self.buf_id)
if start < 0:
start = 0
if start >= self.size:
start = self.size - 1
if end < 0:
end = 0
if end >= self.size:
end = self.size - 1
try:
os.lseek(self.shm_obj.fd, self.offset(channel, start), os.SEEK_SET)
slc = os.read(self.shm_obj.fd, (end - start) * self.FLOAT_SIZE)
self.outlets[1] = list(numpy.fromstring(slc, dtype=numpy.float32))
except Exception as e:
import traceback
tb = traceback.format_exc()
log.debug("buffer~: slice error '%s" % e)
self.error(tb)
return None
def grab_handler(stage, event):
try:
r = self.input_mgr.handle_event(stage, event)
if not self.embed.has_focus():
log.debug("event handler: do not have focus")
if hasattr(event, 'keyval'):
log.debug("keyval was", event.keyval)
else:
log.debug("event was:", event.type)
self.grab_focus()
return False
return r
except Exception as e:
import traceback
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def run(self):
from mfp import log
while not self.join_req:
try:
if self.process:
fileobj = self.process.stdout
r, w, e = select.select([fileobj], [], [], 0.25)
if fileobj in r:
ll = fileobj.readline().decode()
else:
continue
else:
ll = None
if not ll:
self.join_req = True
else:
ll = ll.strip()
if ll.startswith("[LOG] "):
ll = ll[6:]
if ll.startswith("FATAL:"):
log.error(ll[7:], module=self.log_module)
self.join_req = True
elif ll.startswith("ERROR:"):
log.error(ll[7:], module=self.log_module)
elif ll.startswith("WARNING:"):
log.warning(ll[9:], module=self.log_module)
elif ll.startswith("INFO:"):
log.info(ll[6:], module=self.log_module)
elif ll.startswith("DEBUG:"):
log.debug(ll[7:], module=self.log_module)
elif ll.startswith("JackEngine::XRun"):
log.warning("JACK: " + ll, module=self.log_module)
elif ll.startswith("JackAudioDriver"):
if "Process error" in ll:
log.error("JACK: " + ll, module=self.log_module)
elif self.log_raw and len(ll):
log.debug("%s " % self.log_module, ll)
except Exception as e:
log.debug("RPCExecRemote: exiting with error", e)
self.join_req = True
if self.process:
self.process.terminate()
self.process.wait()
