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