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 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 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 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 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 __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 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 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 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 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 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 _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 _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 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 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()