def quick_evaluation(self,color):
if color==2:
answer=self.play_white()
else:
answer=self.play_black()
all_moves=self.get_all_leela_zero_moves()
print all_moves[0]
for e in all_moves[0]:
print "\t",e
if answer.lower()=="pass":
self.undo()
return _("That game is won")
elif answer.lower()=="resign":
self.undo_resign()
return _("That game is lost")
else:
self.undo()
sequence_first_move,one_sequence,one_value_network,one_policy_network,one_nodes = all_moves[0]
if color==1:
black_win_rate=str(one_value_network)+'%'
white_win_rate=str(100-one_value_network)+'%'
else:
black_win_rate=str(100-one_value_network)+'%'
white_win_rate=str(one_value_network)+'%'
return _("black/white win probability for this variation: ")+black_win_rate+'/'+white_win_rate
def save(self):
bot = self.name
log("Saving " + bot + " settings")
Config = configparser.ConfigParser()
Config.read(config_file)
Config.set(bot, "SlowCommand", self.SlowCommand.get())
Config.set(bot, "SlowParameters", self.SlowParameters.get())
Config.set(bot, "SlowTimePerMove", self.SlowTimePerMove.get())
Config.set(bot, "FastCommand", self.FastCommand.get())
Config.set(bot, "FastParameters", self.FastParameters.get())
Config.set(bot, "FastTimePerMove", self.FastTimePerMove.get())
value = {
_("Slow profile"): "slow",
_("Fast profile"): "fast",
_("Both profiles"): "both",
_("None"): "none"
}
Config.set(bot, "AnalysisBot", value[self.analysis_bot.get()])
Config.set(bot, "LiveanalysisBot", value[self.liveanalysis_bot.get()])
Config.set(bot, "LivePlayerBot", value[self.liveplayer_bot.get()])
Config.set(bot, "ReviewBot", value[self.review_bot.get()])
Config.write(open(config_file, "w"))
def save(self):
log("Saving GnuGo settings")
Config = ConfigParser.ConfigParser()
Config.read(config_file)
bot = "GnuGo"
Config.set(bot, "SlowCommand", self.SlowCommand.get())
Config.set(bot, "SlowParameters", self.SlowParameters.get())
Config.set(bot, "Variations", self.Variations.get())
Config.set(bot, "Deepness", self.Deepness.get())
Config.set(bot, "FastCommand", self.FastCommand.get())
Config.set(bot, "FastParameters", self.FastParameters.get())
value = {
_("Slow profile"): "slow",
_("Fast profile"): "fast",
_("Both profiles"): "both",
_("None"): "none"
}
Config.set(bot, "AnalysisBot", value[self.analysis_bot.get()])
Config.set(bot, "LiveanalysisBot", value[self.liveanalysis_bot.get()])
Config.set(bot, "LivePlayerBot", value[self.liveplayer_bot.get()])
Config.set(bot, "ReviewBot", value[self.review_bot.get()])
Config.write(open(config_file, "w"))
def update_black_white_options(self):
i=self.selected_black_index()
self.black_options=[_("Human"),_("Bot used for analysis")+" ("+self.bot_selection.get()+")"]+self.bots_names
self.black_menu.pack_forget()
self.black_menu=apply(OptionMenu,(self.black_selection_wrapper,self.black_selection)+tuple(self.black_options))
self.black_menu.pack()
self.black_selection.set(self.black_options[i])
j=self.selected_white_index()
self.white_options=[_("Human"),_("Bot used for analysis")+" ("+self.bot_selection.get()+")"]+self.bots_names
self.white_menu.pack_forget()
self.white_menu=apply(OptionMenu,(self.white_selection_wrapper,self.white_selection)+tuple(self.white_options))
self.white_menu.pack()
self.white_selection.set(self.white_options[j])
if i==1:
black=self.bot_selection.get()
else:
black=self.black_selection.get()
if j==1:
white=self.bot_selection.get()
else:
white=self.white_selection.get()
self.filename.delete(0, END)
filename=datetime.now().strftime('%Y-%m-%d_%H:%M_'+black+'_vs_'+white+'.sgf')
self.filename.insert(0, filename)
def save(self):
bot = self.name
log("Saving " + bot + " settings")
grp_config.set(bot, "SlowCommand", self.SlowCommand.get())
grp_config.set(bot, "SlowParameters", self.SlowParameters.get())
grp_config.set(bot, "SlowTimePerMove", self.SlowTimePerMove.get())
grp_config.set(bot, "FastCommand", self.FastCommand.get())
grp_config.set(bot, "FastParameters", self.FastParameters.get())
grp_config.set(bot, "FastTimePerMove", self.FastTimePerMove.get())
value = {
_("Slow profile"): "slow",
_("Fast profile"): "fast",
_("Both profiles"): "both",
_("None"): "none"
}
grp_config.set(bot, "AnalysisBot", value[self.analysis_bot.get()])
grp_config.set(bot, "LiveanalysisBot",
value[self.liveanalysis_bot.get()])
grp_config.set(bot, "LivePlayerBot", value[self.liveplayer_bot.get()])
grp_config.set(bot, "ReviewBot", value[self.review_bot.get()])
if self.parent.parent.refresh != None:
self.parent.parent.refresh()
def save(self):
log("Saving GnuGo settings")
bot = "GnuGo"
grp_config.set(bot, "SlowCommand", self.SlowCommand.get())
grp_config.set(bot, "SlowParameters", self.SlowParameters.get())
grp_config.set(bot, "Variations", self.Variations.get())
grp_config.set(bot, "Deepness", self.Deepness.get())
grp_config.set(bot, "FastCommand", self.FastCommand.get())
grp_config.set(bot, "FastParameters", self.FastParameters.get())
value = {
_("Slow profile"): "slow",
_("Fast profile"): "fast",
_("Both profiles"): "both",
_("None"): "none"
}
grp_config.set(bot, "AnalysisBot", value[self.analysis_bot.get()])
grp_config.set(bot, "LiveanalysisBot",
value[self.liveanalysis_bot.get()])
grp_config.set(bot, "LivePlayerBot", value[self.liveplayer_bot.get()])
grp_config.set(bot, "ReviewBot", value[self.review_bot.get()])
if self.parent.parent.refresh != None:
self.parent.parent.refresh()
def quick_evaluation(self,color):
if color==2:
answer=self.play_white()
else:
answer=self.play_black()
position_evaluation=self.get_all_leela_moves()
if answer.lower()=="pass":
self.undo()
elif answer.lower()=="resign":
self.undo_resign()
else:
self.undo()
txt=""
try:
if color==1:
black_win_rate=position_evaluation["variations"][0]["win rate"]
white_win_rate=opposite_rate(black_win_rate)
else:
white_win_rate=position_evaluation["variations"][0]["win rate"]
black_win_rate=opposite_rate(white_win_rate)
txt+= _("black/white win probability for this variation: ")+black_win_rate+'/'+white_win_rate
txt+="\n\n"+_("Score estimation for this variation: %s")%self.get_leela_final_score()
except:
txt+=_("Score estimation for this variation: %s")%self.get_leela_final_score()
return txt
def save(self):
global lang, translations
log("Saving GRP settings")
for lang2, language in available_translations.iteritems():
if language==self.Language.get():
if lang!=lang2:
grp_config.set("General","Language",lang2)
break
grp_config.set("Review","FuzzyStonePlacement",self.FuzzyStonePlacement.get())
grp_config.set("Review","RealGameSequenceDeepness",self.RealGameSequenceDeepness.get())
#grp_config.set("Review","GobanScreenRatio",self.GobanScreenRatio.get())
grp_config.set("Analysis","MaxVariations",self.MaxVariationsToRecord.get())
grp_config.set("Analysis","SaveCommandLine",self.SaveCommandLine.get())
grp_config.set("Analysis","StopAtFirstResign",self.StopAtFirstResign.get())
grp_config.set("Review","MaxVariations",self.MaxVariationsToDisplay.get())
coloring={_("Win rate > 50% in blue"):"blue_for_winning",_("The best variation in blue"):"blue_for_best",_("Variations better than actual game move in blue"):"blue_for_better"}
grp_config.set("Review","VariationsColoring",coloring[self.VariationsColoring.get()])
grp_config.set("Review","InvertedMouseWheel",self.InvertedMouseWheel.get())
grp_config.set("Analysis","NoVariationIfSameMove",self.NoVariationIfSameMove.get())
labeling={_("Letters"):"letter",_("Percentages"):"rate"}
grp_config.set("Review","VariationsLabel",labeling[self.VariationsLabel.get()])
if self.refresh!=None:
self.refresh()
def save(self):
log("Saving Ray settings")
Config = ConfigParser.ConfigParser()
Config.read(config_file)
bot = "Ray"
Config.set(bot, "SlowCommand", self.SlowCommand.get())
Config.set(bot, "SlowParameters", self.SlowParameters.get())
Config.set(bot, "FastCommand", self.FastCommand.get())
Config.set(bot, "FastParameters", self.FastParameters.get())
value = {
_("Slow profile"): "slow",
_("Fast profile"): "fast",
_("Both profiles"): "both",
_("None"): "none"
}
Config.set(bot, "AnalysisBot", value[self.analysis_bot.get()])
Config.set(bot, "LiveanalysisBot", value[self.liveanalysis_bot.get()])
Config.set(bot, "LivePlayerBot", value[self.liveplayer_bot.get()])
Config.set(bot, "ReviewBot", value[self.review_bot.get()])
Config.write(open(config_file, "w"))
if self.parent.parent.refresh != None:
self.parent.parent.refresh()
def click_button(self, bot):
dim = self.dim
self.display_queue.put(3)
self.display_queue.put(2)
color = self.next_color
move = bot.click(color)
if move not in ["PASS", "RESIGN"]:
i, j = gtp2ij(move)
self.history.append(
[copy(self.grid),
copy(self.markup), (move, color)])
place(self.grid, i, j, color)
self.display_queue.put((i, j))
self.grid[i][j] = color
self.markup = [["" for r in range(dim)] for c in range(dim)]
self.markup[i][j] = 0
self.next_color = 3 - color
else:
bot.undo()
if color == 1:
self.display_queue.put(bot.name + " (" + _("Black") + "): " +
move)
else:
self.display_queue.put(bot.name + " (" + _("White") + "): " +
move)
self.do_nothing()
return
if self.white_autoplay and self.black_autoplay:
if move not in ["PASS", "RESIGN"]:
log("SELF PLAY")
self.display_queue.put(2)
one_thread = threading.Thread(
target=self.click_button,
args=(self.menu_bots[self.selected_bot.get()], ))
self.after(0, one_thread.start)
return
else:
log("End of SELF PLAY")
self.display_queue.put(4)
self.display_queue.put(1)
self.do_nothing()
return
else:
self.display_queue.put(4)
self.display_queue.put(1)
return
def start(self):
#bots={bot['name']:bot for bot in bots_for_analysis}
#analyser=bots[self.bot_selection.get()]
value={"slow":" (%s)"%_("Slow profile"),"fast":" (%s)"%_("Fast profile")}
bots={bot['name']+value[bot['profile']]:bot for bot in get_available("LiveAnalysisBot")}
analyser=bots[self.bot_selection.get()]
bots={bot['name']+value[bot['profile']]:bot for bot in get_available("LivePlayerBot")}
b=self.selected_black_index()
if b==0:
black="human"
elif b==1:
black="analyser"
else:
print "=========="
print bots.keys()
print "=========="
black=bots[self.black_selection.get()]
w=self.selected_white_index()
if w==0:
white="human"
elif w==1:
white="analyser"
elif w==b:
white="black"
else:
white=bots[self.white_selection.get()]
Config = ConfigParser.ConfigParser()
Config.read(config_file)
komi=float(self.komi.get())
dim=int(self.dim.get())
handicap=int(self.handicap.get())
Config.set("Live","komi",komi)
Config.set("Live","size",dim)
Config.set("Live","handicap",handicap)
Config.set("Live","analyser",self.bot_selection.get().encode("utf"))
Config.set("Live","black",self.black_selection.get().encode("utf"))
Config.set("Live","white",self.white_selection.get().encode("utf"))
Config.write(open(config_file,"w"))
filename=os.path.join(Config.get("General","livefolder"),self.filename.get())
self.withdraw()
popup=LiveAnalysis(self.parent,analyser,black,white,dim=dim,komi=komi,handicap=handicap,filename=filename,overlap_thinking=not self.no_overlap_thinking.get(),color=self.color.get())
self.parent.add_popup(popup)
self.close()
def pause(self):
if self.pause_button.cget("relief")!=SUNKEN:
log("Pausing the game")
self.pause_button.config(relief=SUNKEN)
self.pause_button.config(text=_("Resume"))
self.pause_lock.acquire()
log("Game paused")
else:
log("Resuming the game")
self.pause_button.config(relief=RAISED)
self.pause_button.config(text=_("Pause"))
self.pause_lock.release()
log("Game resumed")
def quick_evaluation(self, color):
if color == 2:
answer = self.play_white()
else:
answer = self.play_black()
all_moves = self.get_all_aq_moves()
if answer.lower() == "pass":
self.undo()
elif answer.lower() == "resign":
self.undo_resign()
else:
self.undo()
txt = ""
try:
if color == 1:
black_win_rate = str(all_moves[0][2]) + "%"
white_win_rate = opposite_rate(black_win_rate)
else:
white_win_rate = str(all_moves[0][2]) + "%"
black_win_rate = opposite_rate(white_win_rate)
txt += _(
"Value network black/white win probability for this variation: %s"
) % (black_win_rate + '/' + white_win_rate)
except:
pass
return txt
def display_settings(self):
if self.setting_frame:
self.setting_frame.pack_forget()
settings_dict = {
"GRP": self.display_GRP_settings,
"AQ": AQSettings,
"GnuGo": GnuGoSettings,
"Leela": LeelaSettings,
"Ray": RaySettings,
"Leela Zero": LeelaZeroSettings
}
self.setting_frame = Frame(self.right_column)
self.setting_frame.parent = self
key = self.setting_mode.get()
new_settings = settings_dict[key](self.setting_frame)
new_settings.grid(row=0, column=0, padx=5, pady=5)
self.current_settings = new_settings
Button(self.setting_frame,
text=_("Save settings"),
command=new_settings.save).grid(row=1,
column=0,
padx=5,
pady=5,
sticky=W)
self.setting_frame.pack()
self.focus()
def update_overlap_thinking_option(self):
i=self.selected_black_index()
j=self.selected_white_index()
if i<=1 and j<=1:
nb_bots=1
elif (i>1 and j<=1) or (j>1 and i<=1):
nb_bots=2
elif (i>1 and j>1 and i==j):
nb_bots=2
elif (i>1 and j>1 and i!=j):
nb_bots=3
for widget in self.overlap_thinking_widgets:
widget.grid_forget()
self.overlap_thinking_widgets=[]
if nb_bots>1:
row=0
widget=Label(self.overlap_thinking_wrapper,text="")
widget.grid(row=row,column=1)
self.overlap_thinking_widgets.append(widget)
row+=1
widget=Label(self.overlap_thinking_wrapper,text=_("No overlap thinking time"))
widget.grid(row=row,column=1,sticky=W)
self.overlap_thinking_widgets.append(widget)
widget=Checkbutton(self.overlap_thinking_wrapper, text="", variable=self.no_overlap_thinking,onvalue=True,offvalue=False)
widget.grid(row=row,column=2,sticky=W)
self.overlap_thinking_widgets.append(widget)
def remove_bot(self,bot):
self.bots_menubutton.menu.delete(bot)
self.actions_menubutton.config(state="disabled")
del self.menu_bots[bot]
if len(self.menu_bots)==0:
self.bots_menubutton.config(state="disabled")
self.current_bot=_("No bot")
def close(self):
log("Closing analyser bot")
self.game_label.config(text=_("Now closing, please wait"))
self.analysis_label.config(text=_("Now closing, please wait"))
self.analyser.update_queue.put(None)
if type(self.black)!=type("abc"):
log("Closing black bot")
self.black.close()
if type(self.white)!=type("abc"):
log("Closing white bot")
self.white.close()
self.analyser.bot.close()
self.popup.destroy()
def __init__(self,parent,bot_gtp,bot_command_line):
Toplevel.__init__(self,parent)
self.parent=parent
self.protocol("WM_DELETE_WINDOW", self.close)
try:
self.bot=bot_gtp(bot_command_line)
except Exception, e:
show_error(_("Could not run the program:")+"\n"+str(e),self.parent)
def close(self):
log("Closing analyser bot")
self.game_label.config(text=_("Now closing, please wait"))
self.analysis_label.config(text=_("Now closing, please wait"))
log("Sending None msg to analyser")
self.analyser.update_queue.put((0,None))
if type(self.black)!=type("abc"):
log("Closing black bot")
self.black.close()
if type(self.white)!=type("abc"):
log("Closing white bot")
self.white.close()
self.analyser.bot.close()
self.destroy()
self.parent.remove_popup(self)
def undo(self):
log("Let's wait for the analyser to stop")
self.analyser.cpu_lock.acquire()
log("Analyser is now stopped")
log("Adding a new branch to the SGF tree")
self.g.lock.acquire()
new_branch=self.latest_node.parent.parent.parent.new_child(0)
self.g.lock.release()
move2undo=self.current_move-2
log("Let's clean the analyser update_queue from requests for moves following move",move2undo)
nb_request=self.analyser.update_queue.qsize()
requests=[]
for r in range(nb_request):
priority,msg=self.analyser.update_queue.get()
if type(msg)==type(123):
if msg<=move2undo:
log("keeping",(priority,msg))
requests.append((priority,msg))
#self.analyser.update_queue.put((priority,msg))
else:
log("discarding",(priority,msg))
else:
log("keeping",(priority,msg))
requests.append((priority,msg))
for r in requests:
self.analyser.update_queue.put(r)
log("Sending a priority request to undo move",move2undo,"and beyong to analyser")
msg1=(1./move2undo,"undo "+str(move2undo))
self.analyser.update_queue.put(msg1)
log("Releasing the analyser")
self.analyser.cpu_lock.release()
self.latest_node=new_branch
if type(self.black)!=type("abc"):
#black is a bot
self.black.undo()
self.black.undo()
if type(self.white)!=type("abc"):
#white is a bot
self.white.undo()
self.white.undo()
self.history.pop()
self.grid,self.markup=self.history.pop()
self.current_move-=2
self.game_label.config(text=_("Currently at move %i")%self.current_move)
write_rsgf(self.rsgf_filename,self.g)
log("waiting for echo")
t0=time.time()
msg2=None
while msg2!=msg1:
msg2=self.analyser.best_moves_queue.get()
log("...............",msg2)
log("echo received after",time.time()-t0,"s")
self.parent.after(10,self.after_undo) #enough time for analyser to grab the process lock and process the queue
def __init__(self,parent):
Frame.__init__(self,parent)
self.parent=parent
log("Initializing Ray setting interface")
bot="Ray"
row=0
Label(self,text=_("%s settings")%bot, font="-weight bold").grid(row=row,column=1,sticky=W)
row+=1
Label(self,text="").grid(row=row,column=1)
row+=1
Label(self,text=_("Slow profile parameters")).grid(row=row,column=1,sticky=W)
row+=1
Label(self,text=_("Command")).grid(row=row,column=1,sticky=W)
SlowCommand = StringVar()
SlowCommand.set(grp_config.get(bot,"SlowCommand"))
Entry(self, textvariable=SlowCommand, width=30).grid(row=row,column=2)
row+=1
Label(self,text=_("Parameters")).grid(row=row,column=1,sticky=W)
SlowParameters = StringVar()
SlowParameters.set(grp_config.get(bot,"SlowParameters"))
Entry(self, textvariable=SlowParameters, width=30).grid(row=row,column=2)
row+=1
Button(self, text=_("Test"),command=lambda: self.parent.parent.test(Ray_gtp,"slow")).grid(row=row,column=1,sticky=W)
row+=1
Label(self,text="").grid(row=row,column=1)
row+=1
Label(self,text=_("Fast profile parameters")).grid(row=row,column=1,sticky=W)
row+=1
row+=1
Label(self,text=_("Command")).grid(row=row,column=1,sticky=W)
FastCommand = StringVar()
FastCommand.set(grp_config.get(bot,"FastCommand"))
Entry(self, textvariable=FastCommand, width=30).grid(row=row,column=2)
row+=1
Label(self,text=_("Parameters")).grid(row=row,column=1,sticky=W)
FastParameters = StringVar()
FastParameters.set(grp_config.get(bot,"FastParameters"))
Entry(self, textvariable=FastParameters, width=30).grid(row=row,column=2)
row+=1
Button(self, text=_("Test"),command=lambda: self.parent.parent.test(Ray_gtp,"fast")).grid(row=row,column=1,sticky=W)
self.SlowCommand=SlowCommand
self.SlowParameters=SlowParameters
self.FastCommand=FastCommand
self.FastParameters=FastParameters
def click(self,event):
if self.locked:
return
dim=self.dim
#add/remove black stone
#check pointer location
i,j=self.goban.xy2ij(event.x,event.y)
color=self.next_color
if 0 <= i <= dim-1 and 0 <= j <= dim-1:
#inside the grid
#what is under the pointer ?
if self.grid[i][j] not in (1,2):
#nothing, so we add a stone
self.history.append([copy(self.grid),copy(self.markup)])
place(self.grid,i,j,color)
self.grid[i][j]=color
self.markup=[["" for r in range(dim)] for c in range(dim)]
self.markup[i][j]=0
self.goban.display(self.grid,self.markup)
if color==1:
self.goban.black_stones[i][j].shine()
else:
self.goban.white_stones[i][j].shine()
self.stone_sound()
self.next_color=3-color
self.g.lock.acquire()
node = self.latest_node
if color==1:
node_set(node,"b", (i,j))
else:
node_set(node,"w", (i,j))
self.g.lock.release()
self.current_move+=1
self.game_label.config(text=_("Currently at move %i")%self.current_move)
if self.next_color==1:
self.white_just_passed=False
if type(self.black)!=type("abc"):
#black is a bot
log("Asking black (%s) to play the game move"%self.black.bot_name)
self.black.place_white(ij2gtp((i,j)))
self.black_to_play()
else:
self.black_just_passed=False
if type(self.white)!=type("abc"):
#white is a bot
log("Asking white (%s) to play the game move"%self.white.bot_name)
self.white.place_black(ij2gtp((i,j)))
self.white_to_play()
def r2sgf(self):
filename = open_rsgf_file(parent=self.parent)
if not filename:
return
rsgf2sgf(filename)
show_info(
_("The file %s as been converted to %s") %
(os.path.basename(filename), os.path.basename(filename) + ".sgf"),
parent=self.parent)
def __init__(self,parent,bot="GnuGo"):
Frame.__init__(self,parent)
self.parent=parent
self.bot=bot
self.profiles=get_bot_profiles(bot,False)
profiles_frame=self
self.listbox = Listbox(profiles_frame)
self.listbox.grid(column=10,row=10,rowspan=10)
self.update_listbox()
row=10
Label(profiles_frame,text=_("Profile")).grid(row=row,column=11,sticky=W)
self.profile = StringVar()
Entry(profiles_frame, textvariable=self.profile, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Command")).grid(row=row,column=11,sticky=W)
self.command = StringVar()
Entry(profiles_frame, textvariable=self.command, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Parameters")).grid(row=row,column=11,sticky=W)
self.parameters = StringVar()
Entry(profiles_frame, textvariable=self.parameters, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Maximum number of variations")).grid(row=row,column=11,sticky=W)
self.variations = StringVar()
Entry(profiles_frame, textvariable=self.variations, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Deepness for each variation")).grid(row=row,column=11,sticky=W)
self.deepness = StringVar()
Entry(profiles_frame, textvariable=self.deepness, width=30).grid(row=row,column=12)
row+=10
buttons_frame=Frame(profiles_frame)
buttons_frame.grid(row=row,column=10,sticky=W,columnspan=3)
Button(buttons_frame, text=_("Add profile"),command=self.add_profile).grid(row=row,column=1,sticky=W)
Button(buttons_frame, text=_("Modify profile"),command=self.modify_profile).grid(row=row,column=2,sticky=W)
Button(buttons_frame, text=_("Delete profile"),command=self.delete_profile).grid(row=row,column=3,sticky=W)
Button(buttons_frame, text=_("Test"),command=lambda: self.parent.parent.test(self.bot_gtp,self.command,self.parameters)).grid(row=row,column=4,sticky=W)
self.listbox.bind("<Button-1>", lambda e: self.after(100,self.change_selection))
self.index=-1
self.bot_gtp=GnuGo_gtp
def __init__(self,parent,bot="GnuGo"):
Frame.__init__(self,parent)
self.parent=parent
self.bot=bot
self.profiles=get_bot_profiles(bot,False)
profiles_frame=self
self.listbox = Listbox(profiles_frame)
self.listbox.grid(column=10,row=10,rowspan=10)
self.update_listbox()
row=10
Label(profiles_frame,text=_("Profile")).grid(row=row,column=11,sticky=W)
self.profile = StringVar()
Entry(profiles_frame, textvariable=self.profile, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Command")).grid(row=row,column=11,sticky=W)
self.command = StringVar()
Entry(profiles_frame, textvariable=self.command, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Parameters")).grid(row=row,column=11,sticky=W)
self.parameters = StringVar()
Entry(profiles_frame, textvariable=self.parameters, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Maximum number of variations")).grid(row=row,column=11,sticky=W)
self.variations = StringVar()
Entry(profiles_frame, textvariable=self.variations, width=30).grid(row=row,column=12)
row+=1
Label(profiles_frame,text=_("Deepness for each variation")).grid(row=row,column=11,sticky=W)
self.deepness = StringVar()
Entry(profiles_frame, textvariable=self.deepness, width=30).grid(row=row,column=12)
row+=10
buttons_frame=Frame(profiles_frame)
buttons_frame.grid(row=row,column=10,sticky=W,columnspan=3)
Button(buttons_frame, text=_("Add profile"),command=self.add_profile).grid(row=row,column=1,sticky=W)
Button(buttons_frame, text=_("Modify profile"),command=self.modify_profile).grid(row=row,column=2,sticky=W)
Button(buttons_frame, text=_("Delete profile"),command=self.delete_profile).grid(row=row,column=3,sticky=W)
Button(buttons_frame, text=_("Test"),command=lambda: self.parent.parent.test(self.bot_gtp,self.command,self.parameters)).grid(row=row,column=4,sticky=W)
self.listbox.bind("<Button-1>", lambda e: self.after(100,self.change_selection))
self.index=-1
self.bot_gtp=GnuGo_gtp
def __init__(self,parent,bot_gtp,bot_command_line):
Toplevel.__init__(self,parent)
self.parent=parent
self.protocol("WM_DELETE_WINDOW", self.close)
try:
self.bot=bot_gtp(bot_command_line)
except Exception, e:
self.close()
show_error(_("Could not run the program:")+"\n"+unicode(e),self.parent)
return
def close(self):
log("closing tab")
if self.current_bot!=_("No bot"):
self.menu_bots[self.current_bot].close()
try:
self.display_queue.put(0, False)
except:
pass
self.destroy()
log("done")
def change_bot(self):
if self.current_bot!=_("No bot"):
log("Bot changed from '"+self.current_bot+"' to '"+self.selected_bot.get()+"'")
log("Terminating",self.current_bot)
previous_bot=self.menu_bots[self.current_bot]
previous_bot.close()
self.current_bot=_("No bot")
else:
log("Bot selected:",self.selected_bot.get())
if self.selected_bot.get()==_("No bot"):
self.current_bot=_("No bot")
self.actions_menubutton.config(state="disabled")
return
new_bot=self.menu_bots[self.selected_bot.get()]
new_bot.start(silentfail=False)
if not new_bot.okbot:
self.remove_bot(self.selected_bot.get())
self.selected_bot.set(_("No bot"))
self.change_bot()
return
grp_config.set("Review", "LastBot",self.selected_bot.get() )
gameroot=self.sgf.get_root()
m=0
for m in range(1,self.move):
one_move=get_node(gameroot,m)
if one_move==False:
log("(0)leaving because one_move==False")
break
ij=one_move.get_move()[1]
if one_move.get_move()[0]=='b':
color=1
else:
color=2
if not new_bot.place(ij2gtp(ij),color):
self.remove_bot(self.current_bot)
self.selected_bot.set(_("No bot"))
self.change_bot()
return
for __,__,move in self.history:
if not new_bot.place(move[0],move[1]):
self.remove_bot(self.current_bot)
self.selected_bot.set(_("No bot"))
self.change_bot()
return
self.current_bot=self.selected_bot.get()
self.actions_menubutton.config(state="normal")
def __init__(self,command):
self.c=1
self.command_line=command[0]+" "+" ".join(command[1:])
leela_zero_working_directory=command[0][:-len(ntpath.basename(command[0]))]
command=[c.encode(sys.getfilesystemencoding()) for c in command]
leela_zero_working_directory=leela_zero_working_directory.encode(sys.getfilesystemencoding())
if leela_zero_working_directory:
log("Leela Zero working directory:",leela_zero_working_directory)
log(command)
#self.process=subprocess.Popen(command,cwd=leela_zero_working_directory, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
self.process=subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
else:
self.process=subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self.size=0
self.stderr_starting_queue=Queue.Queue(maxsize=100)
self.stderr_queue=Queue.Queue()
self.stdout_queue=Queue.Queue()
threading.Thread(target=self.consume_stderr).start()
log("Checking Leela Zero stderr to check for OpenCL SGEMM tuner running")
delay=60
while 1:
try:
err_line=self.stderr_starting_queue.get(True,delay)
delay=10
if "Started OpenCL SGEMM tuner." in err_line:
log("OpenCL SGEMM tuner is running")
show_info(_("Leela Zero is currently running the OpenCL SGEMM tuner. It may take several minutes until Leela Zero is ready."))
break
elif "Loaded existing SGEMM tuning.\n" in err_line:
log("OpenCL SGEMM tuner has already been runned")
break
elif "Could not open weights file" in err_line:
show_info(err_line.strip())
break
elif "A network weights file is required to use the program." in err_line:
show_info(err_line.strip())
break
elif "Weights file is the wrong version." in err_line:
show_info(err_line.strip())
break
elif "BLAS Core:" in err_line:
log("Could not find out, abandoning")
break
except:
log("Could not find out, abandoning")
break
self.free_handicap_stones=[]
self.history=[]
def follow_analysis(self):
msg=None
try:
msg=self.analyser.label_queue.get(False)
if type(msg)==type(123):
self.analysis_label.config(text=_("Currently at move %i")%msg)
else:
self.analysis_label.config(text=_("Waiting for next move"))
if msg>2 and len(self.review_bouton_wrapper.children)==0:
Button(self.review_bouton_wrapper,text=_("Start review"),command=self.start_review).pack(fill=X)
except:
pass
if msg==None:
self.parent.after(500,self.follow_analysis)
else:
self.parent.after(10,self.follow_analysis)
def __init__(self, parent):
Toplevel.__init__(self, parent)
self.parent = parent
bg = self.cget("background")
self.popups = []
self.control_frame = Frame(self)
label = Label(self.control_frame,
text=_("This is GoReviewPartner"),
font="-weight bold")
label.pack(padx=5, pady=5)
self.analysis_bouton = Button(self.control_frame,
text=_("Run a SGF file analysis"),
command=self.launch_analysis)
self.analysis_bouton.pack(fill=X, padx=5, pady=5)
self.download_bouton = Button(
self.control_frame,
text=_("Download a SGF file for analysis"),
command=self.download_sgf_for_review)
self.download_bouton.pack(fill=X, padx=5, pady=5)
self.live_bouton = Button(self.control_frame,
text=_("Run a live analysis"),
command=self.launch_live_analysis)
self.live_bouton.pack(fill=X, padx=5, pady=5)
review_bouton = Button(self.control_frame,
text=_("Open a RSGF file for review"),
command=self.launch_review)
review_bouton.pack(fill=X, padx=5, pady=5)
r2sgf_bouton = Button(self.control_frame,
text=_("Convert RSGF file to SGF file"),
command=self.r2sgf)
r2sgf_bouton.pack(fill=X, padx=5, pady=5)
bouton = Button(self.control_frame,
text=_("Settings"),
command=self.launch_settings)
bouton.pack(fill=X, padx=5, pady=5)
self.control_frame.pack(fill=X, side=BOTTOM)
self.logo_frame = Frame(self)
logo = Canvas(self.logo_frame, bg=bg, width=5, height=5)
logo.pack(fill=BOTH, expand=1)
logo.bind("<Configure>", lambda e: draw_logo(logo, e))
self.logo_frame.pack(fill=BOTH, side=BOTTOM, expand=1)
self.protocol("WM_DELETE_WINDOW", self.close)
class Terminal(Toplevel):
def __init__(self, parent, bot_gtp, bot_command_line):
Toplevel.__init__(self, parent)
self.parent = parent
self.protocol("WM_DELETE_WINDOW", self.close)
try:
self.bot = bot_gtp(bot_command_line)
except Exception, e:
self.close()
show_error(
_("Could not run the program:") + "\n" + unicode(e),
self.parent)
return
threading.Thread(target=self.bot.consume_stdout).start()
stdin_frame = Frame(self)
stdin_frame.grid(row=1, column=1)
self.gtp_command = StringVar()
self.gtp_command.set("genmove black")
entry = Entry(stdin_frame, textvariable=self.gtp_command)
entry.grid(row=1, column=1, sticky=W)
entry.bind("<Return>", self.send_gtp_command)
Button(stdin_frame,
text=_("Send GTP command"),
command=self.send_gtp_command).grid(row=1, column=2, sticky=W)
stdout_frame = Frame(self)
stdout_frame.grid(row=2, column=1, sticky=N + S + E + W)
self.stdout = Text(stdout_frame,
width=60,
height=10,
bg="black",
fg="white")
self.stdout.pack(side="left", fill="both", expand=True)
stderr_frame = Frame(self)
stderr_frame.grid(row=3, column=1, sticky=N + S + E + W)
self.stderr = Text(stderr_frame,
width=60,
height=20,
bg="black",
fg="white")
self.stderr.pack(side="left", fill="both", expand=True)
self.grid_columnconfigure(1, weight=1)
self.grid_rowconfigure(2, weight=1)
self.grid_rowconfigure(3, weight=1)
self.follow_stdout()
self.follow_stderr()
def __init__(self,command):
self.c=1
self.command_line=command[0]+" "+" ".join(command[1:])
leela_zero_working_directory=command[0][:-len(ntpath.basename(command[0]))]
command=[c.encode(sys.getfilesystemencoding()) for c in command]
leela_zero_working_directory=leela_zero_working_directory.encode(sys.getfilesystemencoding())
if leela_zero_working_directory:
log("Leela Zero working directory:",leela_zero_working_directory)
self.process=subprocess.Popen(command,cwd=leela_zero_working_directory, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
else:
self.process=subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self.size=0
self.stderr_starting_queue=Queue.Queue(maxsize=100)
self.stderr_queue=Queue.Queue()
self.stdout_queue=Queue.Queue()
threading.Thread(target=self.consume_stderr).start()
log("Checking Leela Zero stderr to check for OpenCL SGEMM tuner running")
delay=60
while 1:
try:
err_line=self.stderr_starting_queue.get(True,delay)
delay=10
if "Started OpenCL SGEMM tuner." in err_line:
log("OpenCL SGEMM tuner is running")
show_info(_("Leela Zero is currently running the OpenCL SGEMM tuner. It may take several minutes until Leela Zero is ready."))
break
elif "Loaded existing SGEMM tuning.\n" in err_line:
log("OpenCL SGEMM tuner has already been runned")
break
elif "Could not open weights file" in err_line:
show_info(err_line.strip())
break
elif "A network weights file is required to use the program." in err_line:
show_info(err_line.strip())
break
elif "Weights file is the wrong version." in err_line:
show_info(err_line.strip())
break
elif "BLAS Core:" in err_line:
log("Could not find out, abandoning")
break
except:
log("Could not find out, abandoning")
break
self.free_handicap_stones=[]
self.history=[]
def __init__(self,parent):
Toplevel.__init__(self,parent)
self.parent=parent
bg=self.cget("background")
self.popups=[]
self.control_frame = Frame(self)
label = Label(self.control_frame, text=_("This is GoReviewPartner"), font="-weight bold")
label.pack(padx=5, pady=5)
self.analysis_bouton=Button(self.control_frame, text=_("Run a SGF file analysis"), command=self.launch_analysis)
self.analysis_bouton.pack(fill=X,padx=5, pady=5)
self.download_bouton=Button(self.control_frame, text=_("Download a SGF file for analysis"), command=self.download_sgf_for_review)
self.download_bouton.pack(fill=X,padx=5, pady=5)
self.live_bouton=Button(self.control_frame, text=_("Run a live analysis"), command=self.launch_live_analysis)
self.live_bouton.pack(fill=X,padx=5, pady=5)
review_bouton=Button(self.control_frame, text=_("Open a RSGF file for review"), command=self.launch_review)
review_bouton.pack(fill=X,padx=5, pady=5)
r2sgf_bouton=Button(self.control_frame, text=_("Convert RSGF file to SGF file"), command=self.r2sgf)
r2sgf_bouton.pack(fill=X,padx=5, pady=5)
r2csv_bouton=Button(self.control_frame, text=_("Convert RSGF file to CSV file"), command=self.r2csv)
r2csv_bouton.pack(fill=X,padx=5, pady=5)
bouton=Button(self.control_frame, text=_("Settings"), command=self.launch_settings)
bouton.pack(fill=X,padx=5, pady=5)
self.control_frame.pack(fill=X, side=BOTTOM)
self.logo_frame = Frame(self)
logo = Canvas(self.logo_frame,bg=bg,width=5,height=5)
logo.pack(fill=BOTH, expand=1)
logo.bind("<Configure>",lambda e: draw_logo(logo,e))
self.logo_frame.pack(fill=BOTH, side=BOTTOM, expand=1)
self.protocol("WM_DELETE_WINDOW", self.close)
def __init__(self,command):
self.c=1
self.command_line=command[0]+" "+" ".join(command[1:])
command=[c.encode(sys.getfilesystemencoding()) for c in command]
self.process=subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self.size=0
self.stderr_starting_queue=Queue.Queue(maxsize=100)
self.stderr_queue=Queue.Queue()
self.stdout_queue=Queue.Queue()
threading.Thread(target=self.consume_stderr).start()
log("Checking Ray stderr to check for OpenCL SGEMM tuner running")
delay=60
while 1:
try:
err_line=self.stderr_starting_queue.get(True,delay)
delay=10
if "Started OpenCL SGEMM tuner." in err_line:
log("OpenCL SGEMM tuner is running")
show_info(_("Ray is currently running the OpenCL SGEMM tuner. It may take several minutes until Ray is ready."))
break
elif "Loaded existing SGEMM tuning.\n" in err_line:
log("OpenCL SGEMM tuner has already been runned")
break
elif "BLAS Core:" in err_line:
log("Could not find out, abandoning")
break
elif "Could not open weights file" in err_line:
show_info(err_line.strip())
break
elif "Weights file is the wrong version." in err_line:
show_info(err_line.strip())
break
except:
log("Could not find out, abandoning")
break
self.free_handicap_stones=[]
self.history=[]
def r2csv(self):
filename = open_rsgf_file(parent=self.parent)
if not filename:
return
rsgf2csv(filename)
show_info(_("The file %s has been converted to %s")%(os.path.basename(filename),os.path.basename(filename)+".csv"),parent=self.parent)
def run_analysis(self,current_move):
one_move=go_to_move(self.move_zero,current_move)
player_color=guess_color_to_play(self.move_zero,current_move)
gnugo=self.gnugo
log()
log("==============")
log("move",str(current_move))
final_score=gnugo.get_gnugo_estimate_score()
#linelog(final_score)
es=final_score.split()[0]
if es[0]=="B":
lbs="B%+d"%(-1*float(final_score.split()[3][:-1]))
ubs="B%+d"%(-1*float(final_score.split()[5][:-1]))
else:
ubs="W%+d"%(float(final_score.split()[3][:-1]))
lbs="W%+d"%(float(final_score.split()[5][:-1]))
node_set(one_move,"ES",es)
node_set(one_move,"UBS",ubs)
node_set(one_move,"LBS",lbs)
if player_color in ('w',"W"):
log("gnugo plays white")
top_moves=gnugo.gnugo_top_moves_white()
answer=gnugo.play_white()
else:
log("gnugo plays black")
top_moves=gnugo.gnugo_top_moves_black()
answer=gnugo.play_black()
log("====","Gnugo answer:",answer)
node_set(one_move,"CBM",answer)
log("==== Gnugo top moves")
for one_top_move in top_moves:
log("\t",one_top_move)
log()
top_moves=top_moves[:min(self.nb_variations,self.maxvariations)]
if (answer not in ["PASS","RESIGN"]):
gnugo.undo()
while len(top_moves)>0:
all_threads=[]
for worker in self.workers:
worker.need_undo=False
if len(top_moves)>0:
one_top_move=top_moves.pop(0)
if player_color in ('w',"W"):
worker.place_white(one_top_move)
one_thread=threading.Thread(target=get_full_sequence_threaded,args=(worker,'b',self.deepness))
else:
worker.place_black(one_top_move)
one_thread=threading.Thread(target=get_full_sequence_threaded,args=(worker,'w',self.deepness))
worker.need_undo=True
one_thread.one_top_move=one_top_move
one_thread.start()
all_threads.append(one_thread)
for one_thread in all_threads:
one_thread.join()
for worker in self.workers:
if worker.need_undo:
worker.undo()
for one_thread in all_threads:
if type(one_thread.sequence)!=type(["list"]):
raise GRPException(_("GnuGo thread failed:")+"\n"+str(one_thread.sequence))
one_sequence=one_thread.one_top_move+" "+one_thread.sequence[0]
es=one_thread.sequence[1]
one_sequence=one_sequence.strip()
log(">>>>>>",one_sequence)
previous_move=one_move.parent
current_color=player_color
first_move=True
for one_deep_move in one_sequence.split(' '):
if one_deep_move not in ['RESIGN','PASS']:
i,j=gtp2ij(one_deep_move)
new_child=previous_move.new_child()
node_set(new_child,current_color,(i,j))
if first_move:
first_move=False
node_set(new_child,"ES",es)
previous_move=new_child
if current_color in ('w','W'):
current_color='b'
else:
current_color='w'
else:
gnugo.undo()
#one_move.add_comment_text(additional_comments)
log("Creating the influence map")
black_influence=gnugo.get_gnugo_initial_influence_black()
black_territories_points=[]
black_influence_points=[]
white_influence=gnugo.get_gnugo_initial_influence_white()
white_territories_points=[]
white_influence_points=[]
for i in range(self.size):
for j in range(self.size):
if black_influence[i][j]==-3:
black_territories_points.append([i,j])
if white_influence[i][j]==3:
white_territories_points.append([i,j])
if black_influence[i][j]==-2:
black_influence_points.append([i,j])
if white_influence[i][j]==2:
white_influence_points.append([i,j])
if black_influence_points!=[]:
node_set(one_move,"IBM",black_influence_points) #IBM: influence black map
if black_territories_points!=[]:
node_set(one_move,"TBM",black_territories_points) #TBM: territories black map
if white_influence_points!=[]:
node_set(one_move,"IWM",white_influence_points) #IWM: influence white map
if white_territories_points!=[]:
node_set(one_move,"TWM",white_territories_points) #TWM: territories white map
return answer #returning the best move, necessary for live analysis
