def __tune_tonic(self, subj, dummy, arg): print 'tune tonic', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) tonic = int(thing) self[2][3].get_policy().set_value(tonic) self.illuminator.reference_tonic(tonic) return action.nosync_return()
def __set_course_int(self,subject,course,interval): (typ,id) = action.crack_ideal(action.arg_objects(course)[0]) course = int(id) ints = action.mass_quantity(interval) print 'set course',course,'ints',ints self.controller.set_course_steps(int(course),ints) return action.nosync_return()
def __tune_scale(self, subj, dummy, arg): print 'tune scale', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) scale = action.marshal(thing) self[2][2].get_policy().set_value(scale) self.illuminator.reference_scale(scale) return action.nosync_return()
def __cancel_verb(self,subject,phrase): rv=[] for o in action.arg_objects(phrase): type,thing = action.crack_ideal(o) event_id = thing[1] rv.append(action.cancel_return(self.id(),4,event_id)) return rv
def __tune_scale(self,subj,dummy,arg): print 'tune scale',arg type,thing = action.crack_ideal(action.arg_objects(arg)[0]) scale = action.marshal(thing) self[2][2].get_policy().set_value(scale) self.illuminator.reference_scale(scale); return action.nosync_return()
def __tune_tonic(self,subj,dummy,arg): print 'tune tonic',arg type,thing = action.crack_ideal(action.arg_objects(arg)[0]) tonic = int(thing) self[2][3].get_policy().set_value(tonic) self.illuminator.reference_tonic(tonic); return action.nosync_return()
def __crack_arg(self,arg): if logic.is_pred_arity(arg,'cookie',1,1): return str(arg.args[0]) type,thing = action.crack_ideal(action.arg_objects(arg)[0]) cookie = str(thing.args[1][2]) print 'take',arg,'cookie',cookie return cookie
def __do_icon(self,a,b,c,d): print 'icon_manager:__do_icon',a,b,c,d (type,thing) = action.crack_ideal(action.arg_objects(d)[0]) print 'crack', type,thing iconstring=self[2].getIconString(thing) id=action.concrete_object(c) print 'set the icon string on ',id, 'to',iconstring rpc.invoke_rpc(id,'set_icon',logic.render_term(iconstring))
def __choose(self,subj,arg): (type,id) = action.crack_ideal(action.arg_objects(arg)[0]) if id >= self.loopdb.size(): return async.success(errors.doesnt_exist('loop %s' % id,'choose')) file = self.loopdb.basename(id) voice = self[5].current_voice() if not voice: return async.success(errors.no_current_voice('','choose')) voice.set_current(id,file) return action.nosync_return()
def __add(self,subj,arg): if arg is None: return action.nosync_return() (type,id) = action.crack_ideal(action.arg_objects(arg)[0]) if id >= self.loopdb.size(): return async.success(errors.doesnt_exist('loop %s' % str(id),'add')) file = self.loopdb.basename(id) voice = self[5].new_voice() voice.set_current(id,file) return action.nosync_return()
def __riguncreateverb(self, subject, agents): results = [] for a in action.arg_objects(agents): print 'a', a o = action.crack_composite(a, action.crack_concrete) plugin = o[0] rig = o[1] print 'un creating', plugin, 'in', rig result = rpc.invoke_rpc(rig, 'uncreateagent', logic.render_term((plugin, ))) yield result if result.status(): results.extend(logic.parse_clause(result.args()[0])) yield async .Coroutine.success(results)
def verb2_10_associate(self, subject, part, whole): """ associate([],global_associate,role(None,[or([concrete],[virtual]),singular]),role(to,[concrete,singular])) """ part = action.arg_objects(part)[0] whole = action.concrete_object(whole) rel = 'join(%s,role(to,[instance(~self)]))' % part proxy = self.database.find_item(whole) if not proxy: return async .failure('internal error: no proxy') def co(): yield interpreter.RpcAdapter(proxy.invoke_rpc('add_relation', rel)) return async .Coroutine(co(), interpreter.rpcerrorhandler)
def __do_browse(self, subject, *args): print '__do_browse', args #active() o = '' if args: x = action.arg_objects(args[0])[0] if action.is_virtual(x): o = action.crack_virtual(x) elif action.is_concrete(x): o = action.crack_concrete(x) else: o = args[0] print 'o=', o self[8].model.change_target(o)
def __copy(self,sub,take): type,thing = action.crack_ideal(action.arg_objects(take)[0]) id = self.library.nextid() fn = self.library.perm_path(id,None) print 'copy',type,thing,'to',self.id(),fn r = files.copy_file(logic.render_term(thing),fn) yield r if not r.status(): yield async.Coroutine.failure(*r.args()) print 'transfer complete' self.library.add_file(fn) self[5].update() yield async.Coroutine.success(action.nosync_return())
def verb2_20_connect(self, subject, src, dst, dst_chan, src_chan): """ connect([],global_connect,role(None,[or([concrete],[composite([descriptor])])]),role(to,[concrete,singular]),option(into,[mass([channel])]),option(from,[abstract])) """ if dst_chan is not None: dst_chan = int(action.mass_quantity(dst_chan)) if src_chan is not None: src_chan = action.abstract_string(src_chan) src_match = re.match('^channel\s+([\d\.]+)$', src_chan, re.IGNORECASE) if src_match: src_chan = src_match.group(1) else: yield async .Coroutine.failure("%s is not valid" % src_chan) to_descriptor = (action.concrete_object(dst), None) to_descriptor = self.database.to_database_term(to_descriptor) for ff in action.arg_objects(src): if action.is_concrete(ff): from_descriptors = [(action.crack_concrete(ff), None)] else: from_descriptors = action.crack_composite( ff, action.crack_descriptor) from_descriptors = self.database.to_database_term(from_descriptors) r = plumber.plumber(self.database, to_descriptor, from_descriptors, dst_chan=dst_chan, src_chan=src_chan) yield r if not r.status(): yield async .Coroutine.failure(*r.args(), **r.kwds()) yield async .Coroutine.success()
def __unname(self,subj,thing): thing = action.crack_ideal(action.arg_objects(thing)[0])[1] return self[3].unname(thing)
def __name(self,subj,thing,name): thing = action.crack_ideal(action.arg_objects(thing)[0])[1] name = action.abstract_string(name) return self[3].rename(thing,name)
def __choose(self,subj,arg): (type,thing) = action.crack_ideal(action.arg_objects(arg)[0]) return self[3].choose_cookie(thing)
def __choose(self, subj, arg): # resolve the ideal, e.g. type is 'impulse', and cookie is the impulse cookie (type, cookie) = action.crack_ideal(action.arg_objects(arg)[0]) return self[4].choose_cookie(cookie)
def __chooseport(self,subj,arg): print 'choose port',arg print action.arg_objects(arg)[0] (type,thing) = action.crack_ideal(action.arg_objects(arg)[0]) print type,thing self[5].set_port(thing)
def __choose(self, subj, arg): (type, thing) = action.crack_ideal(action.arg_objects(arg)[0]) self.change_device(thing) return action.nosync_return()
def __tune_tonic(self, subj, dummy, arg): print 'set tonic', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) tonic = int(thing) if not self.__fixed: self[4][5].get_policy().set_value(tonic) return action.nosync_return()
def __choose_verb(self, subject, scale): type, thing = action.crack_ideal(action.arg_objects(scale)[0]) print 'choose', scale, thing self[2].reset_to(thing)
def __tune_scale(self, subj, dummy, arg): print 'set scale', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) if not self.__fixed: self[4][7].get_policy().set_value(action.marshal(thing)) return action.nosync_return()