def run(program_text, func):
global all_linear,forcing_ok,stack,directed,solutions,path_constraints
all_linear,forcing_ok = True,True
solutions = {}
path_constraints = {}
program = parseAST(program_text)
program.body = [node for node in program.body if type(node) is FunctionDef and node.name==func.func_name]
func_args = func.func_code.co_varnames[:func.func_code.co_argcount]
import unparseAST
print unparseAST.to_source(program)
print
print
while True:
stack = []
inputs = random_inputs(func_args)
first = inputs
directed = True
while directed:
try:
inputs = execute_program(program,func,inputs)
except KeyboardInterrupt:
raise
except:
from sys import exc_info
from traceback import print_tb
print >> sys.stderr, exc_info()
print_tb(exc_info()[-1])
if forcing_ok:
print "Bug found"
exit()
else:
forcing_ok = True
if first:
solutions[first] = get_solutions(path_constraints[first],first.keys())
solutions[first] = filter_inputs(solutions[first],first.keys())
if all_linear:
break
for key in solutions:
print key
for inputs in sorted(solutions[key]):
print inputs
print
return solutions
def using_constraint_solver(original_csv, output_csv, tempo=120, threshold=7000, offset=0.00, leniency=0.3, num_agents=2):
original_freq_list = mt.create_note_list(original_csv, tempo, threshold, offset=-0.08)
# print(original_freq_list)
original_freq_list = mt.number_converter(original_freq_list)
original_solutions = cs.get_solutions(original_freq_list, num_agents)
print("Original :", original_solutions[0])
# May need to change threshold for output freq list
output_freq_list = mt.create_note_list(output_csv, tempo, threshold=500, offset=-0.08)
output_freq_list = mt.number_converter(output_freq_list)
output_solutions = cs.get_solutions(output_freq_list, num_agents)
for agent, output_solution in enumerate(output_solutions):
index = 0
while index < len(output_solution) and output_solution[index] == -1:
index += 1
output_solutions[agent] = output_solution[index:]
# print("Output: ", output_solutions[0][20:25])
# for output_solution in output_solutions:
# while output_solution[0] == -1:
# output_solution = output_solution[1:]
print("Output:", output_solutions[0])
print("Test: ")
tester = al.Alignment()
a, b = al.Hirschberg.align(tester, seq_a=list(original_solutions[0]), seq_b=list(output_solutions[0]))
print(a)
print(b)
num_errors = 0.0
for i in range(len(original_solutions)):
for j in range(len(original_solutions[0])):
if original_solutions[i][j] != output_solutions[i][j]:
num_errors += 1
if original_solutions and original_solutions[0]:
return num_errors / float(len(original_solutions)*len(original_solutions[0]))
else:
return -1
def run(program_text, func):
global all_linear, forcing_ok, stack, directed, solutions, path_constraints
all_linear, forcing_ok = True, True
solutions = {}
path_constraints = {}
program = parseAST(program_text)
program.body = [
node for node in program.body
if type(node) is FunctionDef and node.name == func.func_name
]
func_args = func.func_code.co_varnames[:func.func_code.co_argcount]
while True:
stack = []
inputs = random_inputs(func_args)
first = inputs
directed = True
while directed:
try:
inputs = execute_program(program, func, inputs)
except KeyboardInterrupt:
raise
except:
from sys import exc_info
from traceback import print_tb
print >> sys.stderr, exc_info()
print_tb(exc_info()[-1])
if forcing_ok:
print "Bug found"
exit()
else:
forcing_ok = True
if first:
solutions[first] = get_solutions(path_constraints[first],
first.keys())
solutions[first] = filter_inputs(solutions[first], first.keys())
if all_linear:
break
return solutions
def solve_path_constraints(tried, constraints, scope_vars): global stack,directed unfinished_index = next_unfinished_branch(tried) if unfinished_index is not None: constraints[unfinished_index] = constraints[unfinished_index].negate() stack[unfinished_index]["branch"] = not stack[unfinished_index]["branch"] new_solutions = get_solutions(constraints[:unfinished_index+1], scope_vars) if new_solutions: stack = stack[:unfinished_index+1] return new_solutions else: return solve_path_constraints(unfinished_index,constraints,scope_vars) else: directed = False return None
def solve_path_constraints(tried, constraints, scope_vars):
global stack, directed
unfinished_index = next_unfinished_branch(tried)
if unfinished_index is not None:
constraints[unfinished_index] = constraints[unfinished_index].negate()
stack[unfinished_index][
"branch"] = not stack[unfinished_index]["branch"]
new_solutions = get_solutions(constraints[:unfinished_index + 1],
scope_vars)
if new_solutions:
stack = stack[:unfinished_index + 1]
return new_solutions
else:
return solve_path_constraints(unfinished_index, constraints,
scope_vars)
else:
directed = False
return None
def run(program_text, func):
global all_linear,forcing_ok,stack,directed,solutions,path_constraints
all_linear,forcing_ok = True,True
solutions = {}
path_constraints = {}
program = parseAST(program_text)
program.body = [node for node in program.body if type(node) is FunctionDef and node.name==func.func_name]
func_args = func.func_code.co_varnames[:func.func_code.co_argcount]
while True:
stack = []
inputs = random_inputs(func_args)
first = inputs
directed = True
while directed:
try:
inputs = execute_program(program,func,inputs)
except KeyboardInterrupt:
raise
except:
if forcing_ok:
print "Bug found"
exit()
else:
forcing_ok = True
if first:
solutions[first] = get_solutions(path_constraints[first],first.keys())
solutions[first] = filter_inputs(solutions[first],first.keys())
if all_linear:
break
return solutions
def main():
#Hardcode number of agents to play song
num_agents = 4
#Obtain song csv and get solutions
#freq_list = mt.create_note_list("Twinkle_Twinkle_Little_Star.csv",120,7000,-.08) #1 Agent
#freq_list = mt.create_note_list("Chopsticks.csv",120,4000,-.15,.03) #2 Agents
freq_list = mt.create_note_list("Bad_Apple.csv", 120, 3000, -.08,
.03) #2 Agents
#freq_list = mt.create_note_list("Grenade_120BPM.csv",120,1500,-.08,.03) #4 Agents
freq_list = mt.number_converter(freq_list)
solutions = cs.get_solutions(freq_list, num_agents)
print(solutions)
#print(solutions)
#Get Mission. Needed for teleport positions.
missionXML = getMissionXML(num_agents)
#Create musician for each agent and pass teleport positions.
musicians = []
for i in range(num_agents):
agent_positions = generateAgentTeleportPositions(note_positions, i)
musicians.append(Musician(agent_positions))
'''
MALMO
'''
print('Starting...', flush=True)
#Create agents.
agent_hosts = []
for i in range(num_agents):
agent_hosts.append(MalmoPython.AgentHost())
malmoutils.parse_command_line(agent_hosts[0])
#Get mission and allow commands for teleport.
my_mission = MalmoPython.MissionSpec(missionXML, True)
my_mission.allowAllChatCommands()
#Add client for each agent needed.
my_client_pool = MalmoPython.ClientPool()
for i in range(num_agents):
my_client_pool.add(MalmoPython.ClientInfo("127.0.0.1", 10000 + i))
MalmoPython.setLogging("", MalmoPython.LoggingSeverityLevel.LOG_OFF)
#Start mission for each agent
for i in range(num_agents):
startMission(
agent_hosts[i], my_mission, my_client_pool,
malmoutils.get_default_recording_object(
agent_hosts[0], "agent_" + str(i + 1) + "_viewpoint_discrete"),
i, '')
#Wait for all missions to begin.
waitForStart(agent_hosts)
#Pause for simulation to begin.
time.sleep(1)
'''
SIMULATION BEGINS HERE
'''
for i in range(len(solutions[0])):
#teleport each agent to the corresponding note.
for j in range(len(musicians)):
musicians[j].teleport_to_noteblock(agent_hosts[j], solutions[j][i])
# play each note.
for k in range(len(musicians)):
if musicians[k].can_play:
agent_hosts[k].sendCommand("attack 1")
time.sleep(0.001)
for k in range(len(musicians)):
if musicians[k].can_play:
agent_hosts[k].sendCommand("attack 0")
musicians[k].can_play = False
#modifies the timing between each note hit.
time.sleep(0.2)
