toolbox.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from traceback import format_exc

class GRPException(Exception):
	def __init__(self,msg):
		if type(msg)==type(u"abc"):
			self.utf_msg=msg
			self.str_msg=msg.encode("utf-8",errors='replace')
		else:
			self.str_msg=msg
			self.utf_msg=msg.decode("utf-8",errors='replace')
		log("===")
		log(format_exc())
		log("===")
		Exception.__init__(self,self.str_msg)

	def __unicode__(self):
		return self.utf_msg

import threading
import codecs

loglock=threading.Lock()
def log(*args):
	global loglock
	loglock.acquire()
	encoding=sys.stdout.encoding
	for arg in args:
		try:
			if type(arg)==type(str('abc')):
				arg=arg.decode('utf-8',errors='replace')
			elif type(arg)!=type(u'abc'):
				try:
					arg=str(arg)
				except:
					arg=unicode(arg,errors='replace')
				arg=arg.decode('utf-8',errors='replace')
			arg=arg.encode(encoding, errors='replace')
			print arg,
		except:
			print "?"*len(arg),
	print
	loglock.release()

def linelog(*args):
	global loglock
	loglock.acquire()
	encoding=sys.stdout.encoding
	for arg in args:
		try:
			if type(arg)==type(str('abc')):
				arg=arg.decode('utf-8',errors='replace')
			elif type(arg)!=type(u'abc'):
				try:
					arg=str(arg)
				except:
					arg=unicode(arg,errors='replace')
				arg=arg.decode('utf-8',errors='replace')
			arg=arg.encode(encoding, errors='replace')
			print arg,
		except:
			print "?"*len(arg),
	loglock.release()

import tkMessageBox

def show_error(txt,parent=None):
	if type(txt)==type(str('abc')):
		txt=txt.decode('utf-8',errors='replace')
	try:
		tkMessageBox.showerror(_("Error"),txt,parent=parent)
		log("ERROR: "+txt)
	except:
		log("ERROR: "+txt)

def show_info(txt,parent=None):
	if type(txt)==type(str('abc')):
		txt=txt.decode('utf-8',errors='replace')
	try:
		tkMessageBox.showinfo(_("Information"),txt,parent=parent)
		log("INFO: "+txt)
	except:
		log("INFO: "+txt)

def get_moves_number(move_zero):
	k=0
	move=move_zero
	while move:
		move=move[0]
		k+=1
	return k

def go_to_move(move_zero,move_number=0):
	if move_number==0:
		return move_zero
	move=move_zero
	k=0
	while k!=move_number:
		if not move:
			log("The end of the sgf tree was reached before getting to move_number",move_number)
			log("Could only reach move_number",k)
			return False
		move=move[0]
		k+=1
	return move


def gtp2ij(move):
	try:
		letters="ABCDEFGHJKLMNOPQRSTUVWXYZ"
		return int(move[1:])-1,letters.index(move[0])
	except:
		raise GRPException("Cannot convert GTP coordinates "+str(move)+" to grid coordinates!")




def ij2gtp(m):
	# (17,0) => a18
	try:
		if m==None:
			return "pass"
		i,j=m
		letters="ABCDEFGHJKLMNOPQRSTUVWXYZ"
		return letters[j]+str(i+1)
	except:
		raise GRPException("Cannot convert grid coordinates "+str(m)+" to GTP coordinates!")

def sgf2ij(m):
	# cj => 8,2
	a, b=m
	letters="abcdefghjklmnopqrstuvwxyz"
	i=letters.index(b)
	j=letters.index(a)
	return i, j
def ij2sgf(m):
	# (17,0) => ???
	try:
		if m==None:
			return "pass"
		i,j=m
		letters=['a','b','c','d','e','f','g','h','j','k','l','m','n','o','p','q','r','s','t']
		return letters[j]+letters[i]
	except:
		raise GRPException("Cannot convert grid coordinates "+str(m)+" to SGF coordinates!")

from gomill import sgf, sgf_moves

from Tkinter import *
#from Tix import Tk, NoteBook
from Tkconstants import *

import sys
import os
import urllib2


class DownloadFromURL(Toplevel):
	def __init__(self,parent,bots=None):
		Toplevel.__init__(self,parent)
		self.bots=bots
		self.parent=parent
		self.title('GoReviewPartner')
		self.config(padx=10,pady=10)

		Label(self,text=_("Paste the URL to the SGF file (http or https):")).grid(row=1,column=1,sticky=W)
		self.url_entry=Entry(self)
		self.url_entry.grid(row=2,column=1,sticky=W)
		self.url_entry.focus()

		Button(self,text=_("Get"),command=self.get).grid(row=3,column=1,sticky=E)

		self.protocol("WM_DELETE_WINDOW", self.close)

	def get(self):
		user_agent = 'GoReviewPartner (https://github.com/pnprog/goreviewpartner/)'
		headers = { 'User-Agent' : user_agent }

		url=self.url_entry.get()
		if not url:
			return

		if url[:4]!="http":
			url="http://"+url

		log("Downloading",url)

		r=urllib2.Request(url,headers=headers)
		try:
			h=urllib2.urlopen(r)
		except:
			show_error(_("Could not open the URL"),parent=self)
			return
		filename=""

		sgf=h.read()

		if sgf[:7]!="(;FF[4]":
			log("not a sgf file")
			show_error(_("Not a valid SGF file!"),parent=self)
			log(sgf[:7])
			return

		try:
			filename=h.info()['Content-Disposition']
			if 'filename="' in filename:
				filename=filename.split('filename="')[0][:-1]
			if "''" in filename:
				filename=filename.split("''")[1]
		except:
			log("no Content-Disposition in header")
			black='black'
			white='white'
			date=""
			if 'PB[' in sgf:
				black=sgf.split('PB[')[1].split(']')[0]
			if 'PW[' in sgf:
				white=sgf.split('PW[')[1].split(']')[0]
			if 'DT[' in sgf:
				date=sgf.split('DT[')[1].split(']')[0]

			filename=""
			if date:
				filename=date+'_'
			filename+=black+'_VS_'+white+'.sgf'

		log(filename)
		game = convert_sgf_to_utf(sgf)
		write_rsgf(filename,game)

		popup=RangeSelector(self.parent,filename,self.bots)
		self.parent.add_popup(popup)
		self.close()

	def close(self):
		log("Closing DownloadFromURL()")
		self.parent.remove_popup(self)
		self.destroy()


filelock=threading.Lock()
c=0
def write_rsgf(filename,sgf_content):
	filelock.acquire()
	global c
	try:
		#log("Saving RSGF file",filename)
		if type(sgf_content)==type("abc"):
			content=sgf_content
		else:
			content=sgf_content.serialise()
		filename2=filename
		if type(filename2)==type(u"abc"):
			if sys.getfilesystemencoding()!="mbcs":
				filename2=filename2.encode(sys.getfilesystemencoding())
		try:
			new_file=open(filename2,'w')
			new_file.write(content)
		except:
			new_file=codecs.open(filename2,"w","utf-8")
			new_file.write(content)

		new_file.close()
		filelock.release()
	except IOError, e:
		filelock.release()
		log("Could not save the RSGF file",filename)
		log("=>", e.errno,e.strerror)
		raise GRPException(_("Could not save the RSGF file: ")+filename+"\n"+e.strerror)
	except Exception,e:
		filelock.release()
		log("Could not save the RSGF file",filename)
		log("=>",e)
		raise GRPException(_("Could not save the RSGF file: ")+filename+"\n"+unicode(e))

def write_sgf(filename,sgf_content):
	filelock.acquire()
	try:
		log("Saving SGF file",filename)
		if type(sgf_content)==type("abc"):
			content=sgf_content
		else:
			content=sgf_content.serialise()
		filename2=filename
		if type(filename2)==type(u"abc"):
			if sys.getfilesystemencoding()!="mbcs":
				filename2=filename2.encode(sys.getfilesystemencoding())
		try:
			new_file=open(filename2,'w')
			new_file.write(content)
		except:
			new_file=codecs.open(filename2,"w","utf-8")
			new_file.write(content)

		new_file.close()
		filelock.release()
	except IOError, e:
		filelock.release()
		log("Could not save the SGF file",filename)
		log("=>", e.errno,e.strerror)
		raise GRPException(_("Could not save the RSGF file: ")+filename+"\n"+e.strerror)
	except Exception,e:
		filelock.release()
		log("Could not save the RSGF file",filename)
		log("=>",e)
		raise GRPException(_("Could not save the SGF file: ")+filename+"\n"+unicode(e))

def convert_sgf_to_utf(content):
	game = sgf.Sgf_game.from_string(content)
	gameroot=game.get_root()
	sgf_moves.indicate_first_player(game) #adding the PL property on the root
	if node_has(gameroot,"CA"):
		ca=node_get(gameroot,"CA")
		if ca=="UTF-8":
			#the sgf is already in UTF, so we accept it directly
			return game
		else:
			log("Encoding is",ca)
			log("Converting from",ca,"to UTF-8")
			encoding=(codecs.lookup(ca).name.replace("_", "-").upper().replace("ISO8859", "ISO-8859")) #from gomill code
			content=game.serialise()
			content=content.decode(encoding,errors='ignore') #transforming content into a unicode object
			content=content.replace("CA["+ca+"]","CA[UTF-8]")
			game = sgf.Sgf_game.from_string(content.encode("utf-8")) #sgf.Sgf_game.from_string requires str object, not unicode
			return game
	else:
		log("the sgf has no declared encoding, we will enforce UTF-8 encoding")
		content=game.serialise()
		content=content.decode("utf",errors="replace").encode("utf")
		game = sgf.Sgf_game.from_string(content,override_encoding="UTF-8")
		return game

def open_sgf(filename):
	filelock.acquire()
	try:
		#log("Opening SGF file",filename)
		filename2=filename
		if type(filename2)==type(u"abc"):
			if sys.getfilesystemencoding()!="mbcs":
				filename2=filename2.encode(sys.getfilesystemencoding())
		txt = open(filename2,'r')
		content=clean_sgf(txt.read())
		txt.close()
		filelock.release()
		game = convert_sgf_to_utf(content)
		return game
	except IOError, e:
		filelock.release()
		log("Could not open the SGF file",filename)
		log("=>", e.errno,e.strerror)
		raise GRPException(_("Could not open the RSGF file: ")+filename+"\n"+e.strerror)
	except Exception,e:
		log("Could not open the SGF file",filename)
		log("=>",e)
		try:
			filelock.release()
		except:
			pass
		raise GRPException(_("Could not open the SGF file: ")+filename+"\n"+unicode(e))

def clean_sgf(txt):
	#txt is still of type str here....

	#https://github.com/pnprog/goreviewpartner/issues/56
	txt=txt.replace(str(";B[  ])"),str(";B[])")).replace(str(";W[  ])"),str(";W[])"))

	#https://github.com/pnprog/goreviewpartner/issues/71
	txt=txt.replace(str("KM[]"),str(""))
	txt=txt.replace(str("B[**];"),str("B[];")).replace(str("W[**];"),str("W[];"))

	return txt
def get_all_sgf_leaves(root,deep=0):

	if len(root)==0:
		#this is a leave
		return [(root,deep)]

	leaves=[]
	deep+=1
	for leaf in root:
		leaves.extend(get_all_sgf_leaves(leaf,deep))

	return leaves

def keep_only_one_leaf(leaf):

	while 1:
		try:
			parent=leaf.parent
			for other_leaf in parent:
				if other_leaf!=leaf:
					log("deleting...")
					other_leaf.delete()
			leaf=parent
		except:
			#reached root
			return

def check_selection(selection,nb_moves):
	move_selection=[]
	selection=selection.replace(" ","")
	for sub_selection in selection.split(","):
		if sub_selection:
			try:
				if "-" in sub_selection:
					a,b=sub_selection.split('-')
					a=int(a)
					b=int(b)
				else:
					a=int(sub_selection)
					b=a
				if a<=b and a>0 and b<=nb_moves:
					move_selection.extend(range(a,b+1))
			except Exception, e:
				print e
				return False
	move_selection=list(set(move_selection))
	move_selection=sorted(move_selection)
	return move_selection

def check_selection_for_color(move_zero,move_selection,color):
	if color=="black":
		new_move_selection=[]
		for m in move_selection:
			player_color=guess_color_to_play(move_zero,m)
			if player_color.lower()=='b':
				new_move_selection.append(m)
		return new_move_selection
	elif color=="white":
		new_move_selection=[]
		for m in move_selection:
			player_color=guess_color_to_play(move_zero,m)
			if player_color.lower()=='w':
				new_move_selection.append(m)
		return new_move_selection
	else:
		return move_selection

class RangeSelector(Toplevel):
	def __init__(self,parent,filename,bots=None):
		Toplevel.__init__(self,parent)
		self.parent=parent
		self.filename=filename
		self.config(padx=10,pady=10)
		root = self
		root.parent.title('GoReviewPartner')
		self.protocol("WM_DELETE_WINDOW", self.close)

		self.bots=bots
		self.g=open_sgf(self.filename)
		self.move_zero=self.g.get_root()
		nb_moves=get_moves_number(self.move_zero)
		self.nb_moves=nb_moves

		row=0
		Label(self,text="").grid(row=row,column=1)

		row+=1
		Label(self,text=_("Bot to use for analysis:")).grid(row=row,column=1,sticky=N+W)
		#value={"slow":" (%s)"%_("Slow profile"),"fast":" (%s)"%_("Fast profile")}
		bot_names=[bot['name']+" - "+bot['profile'] for bot in bots]
		self.bot_selection=StringVar()

		if not bot_names:
			Label(self,text=_("There is no bot configured in Settings")).grid(row=row,column=2,sticky=W)
		else:
		  botOptionMenu = apply(OptionMenu,(self, self.bot_selection)+tuple(bot_names))
		  botOptionMenu.config(width=20)
		  botOptionMenu.grid(row=row,column=2,sticky=W)
		  self.bot_selection.set(bot_names[0])
		
		analyser=grp_config.get("Analysis","analyser")
		if analyser in bot_names:
			self.bot_selection.set(analyser)

		row+=1
		Label(self,text="").grid(row=row,column=1)


		row+=1
		variation_label_widget=Label(self,text=_("Select variation to be analysed"))

		self.leaves=get_all_sgf_leaves(self.move_zero)
		self.variation_selection=StringVar()
		self.variation_selection.trace("w", self.variation_changed)

		options=[]
		v=1
		for unused,deep in self.leaves:
			options.append(_("Variation %i (%i moves)")%(v,deep))
			v+=1
		self.variation_selection.set(options[0])

		variation_menu_widget=apply(OptionMenu,(self,self.variation_selection)+tuple(options))

		existing_variations = StringVar()
		existing_variations.set("remove_everything")

		if node_has(self.move_zero,"RSGF"):
			existing_variations.set("keep")
			row+=10
			Label(self,text=_("This analysis will be performed on an already analysed SGF file.")).grid(row=row,column=1,columnspan=2,sticky=W)
			row+=1
			Label(self,text=_("What to do with the existing variations?")).grid(row=row,column=1,columnspan=2,sticky=W)

			row+=1
			d1=Radiobutton(self,text=_("Keep existing variations"),variable=existing_variations, value="keep")
			d1.grid(row=row,column=1,sticky=W)

			row+=1
			d2=Radiobutton(self,text=_("Replace existing variations"),variable=existing_variations, value="replace")
			d2.grid(row=row,column=1,sticky=W)

		else:
			variation_label_widget.grid(row=row,column=1,sticky=W)
			variation_menu_widget.grid(row=row,column=2,sticky=W)

		self.rsgf_filename=".".join(self.filename.split(".")[:-1])+".rsgf"

		row+=1
		Label(self,text="").grid(row=row,column=1)

		row+=1
		Label(self,text=_("Select moves to be analysed")).grid(row=row,column=1,sticky=W)

		row+=1
		s = StringVar()
		s.set("all")
		self.r1=Radiobutton(self,text=_("Analyse all %i moves")%nb_moves,variable=s, value="all")
		self.r1.grid(row=row,column=1,sticky=W)
		self.after(0,self.r1.select)

		row+=1
		r2=Radiobutton(self,text=_("Analyse only those moves:"),variable=s, value="only")
		r2.grid(row=row,column=1,sticky=W)

		only_entry=Entry(self)
		only_entry.bind("<Button-1>", lambda e: r2.select())
		only_entry.grid(row=row,column=2,sticky=W)
		only_entry.delete(0, END)
		if nb_moves>0:
			only_entry.insert(0, "1-"+str(nb_moves))

		row+=3
		Label(self,text="").grid(row=row,column=1)
		row+=1
		Label(self,text=_("Select colors to be analysed")).grid(row=row,column=1,sticky=W)

		c = StringVar()
		c.set("both")

		row+=1
		c0=Radiobutton(self,text=_("Black & white"),variable=c, value="both")
		c0.grid(row=row,column=1,sticky=W)
		self.after(0,c0.select)

		if node_has(self.move_zero,'PB'):
			black_player=node_get(self.move_zero,'PB')
			if black_player.lower().strip() in ['black','']:
				black_player=''
			else:
				black_player=' ('+black_player+')'
		else:
			black_player=''

		if node_has(self.move_zero,'PW'):
			white_player=node_get(self.move_zero,'PW')
			if white_player.lower().strip() in ['white','']:
				white_player=''
			else:
				white_player=' ('+white_player+')'
		else:
			white_player=''

		row+=1
		c1=Radiobutton(self,text=_("Black only")+black_player,variable=c, value="black")
		c1.grid(row=row,column=1,sticky=W)

		row+=1
		c2=Radiobutton(self,text=_("White only")+white_player,variable=c, value="white")
		c2.grid(row=row,column=1,sticky=W)

		row+=10
		Label(self,text="").grid(row=row,column=1)

		row+=1
		Label(self,text=_("Confirm the value of komi")).grid(row=row,column=1,sticky=W)

		komi_entry=Entry(self)
		komi_entry.grid(row=row,column=2,sticky=W)
		komi_entry.delete(0, END)

		try:
			komi=self.g.get_komi()
			komi_entry.insert(0, str(komi))
		except Exception, e:
			log("Error while reading komi value, please check:\n"+unicode(e))
			show_error(_("Error while reading komi value, please check:")+"\n"+unicode(e),parent=self)
			komi_entry.insert(0, "0")

		row+=10
		Label(self,text="").grid(row=row,column=1)
		row+=1

		Label(self,text=_("Stop the analysis if the bot resigns")).grid(row=row,column=1,sticky=W)
		StopAtFirstResign = BooleanVar(value=grp_config.getboolean('Analysis', 'StopAtFirstResign'))
		StopAtFirstResignCheckbutton=Checkbutton(self, text="", variable=StopAtFirstResign,onvalue=True,offvalue=False)
		StopAtFirstResignCheckbutton.grid(row=row,column=2,sticky=W)
		StopAtFirstResignCheckbutton.var=StopAtFirstResign
		self.StopAtFirstResign=StopAtFirstResign

		row+=10
		Label(self,text="").grid(row=row,column=1)
		row+=1
		start_button=Button(self,text=_("Start"),command=self.start)
		start_button.grid(row=row,column=2,sticky=E)
		if not bot_names:
			start_button.config(state="disabled")
		self.mode=s
		self.color=c
		self.existing_variations=existing_variations
		self.nb_moves=nb_moves
		self.only_entry=only_entry
		self.komi_entry=komi_entry

		self.focus()
		self.parent.focus()

	def variation_changed(self,*unused):
		log("variation changed!",self.variation_selection.get())
		try:
			self.after(0,self.r1.select)
			variation=int(self.variation_selection.get().split(" ")[1])-1
			deep=self.leaves[variation][1]
			self.only_entry.delete(0, END)
			if deep>0:
				self.only_entry.insert(0, "1-"+str(deep))

			self.r1.config(text=_("Analyse all %i moves")%deep)

			self.nb_moves=deep

		except:
			pass

	def close(self):
		self.destroy()
		self.parent.remove_popup(self)

	def start(self):

		#if self.nb_moves==0:
		#	show_error(_("This variation is empty (0 move), the analysis cannot be performed!"),parent=self)
		#	return

		try:
			komi=float(self.komi_entry.get())
		except:
			show_error(_("Incorrect value for komi (%s), please double check.")%self.komi_entry.get(),parent=self)
			return

		if self.bots!=None:
			bot=self.bot_selection.get()
			log("bot selection:",bot)
			bot={bot['name']+" - "+bot['profile']:bot for bot in self.bots}[bot]
			RunAnalysis=bot['runanalysis']


		if self.mode.get()=="all":
			intervals="all moves"
			move_selection=range(1,self.nb_moves+1)
		else:
			selection = self.only_entry.get()
			intervals="moves "+selection
			move_selection=check_selection(selection,self.nb_moves)
			if move_selection==False:
				show_error(_("Could not make sense of the moves range.")+"\n"+_("Please indicate one or more move intervals (e.g. \"10-20, 40,50-51,63,67\")"),parent=self)
				return

		if self.color.get()=="black":
			intervals+=" (black only)"
			log("black only")
		elif self.color.get()=="white":
			intervals+=" (white only)"
			log("white only")
		else:
			intervals+=" (both colors)"

		move_selection=check_selection_for_color(self.move_zero,move_selection,self.color.get())

		log("========= move selection")
		log(move_selection)

		log("========= variation")
		variation=int(self.variation_selection.get().split(" ")[1])-1
		log(variation)

		grp_config.set("Analysis","analyser",self.bot_selection.get())
		grp_config.set("Analysis","StopAtFirstResign",self.StopAtFirstResign.get())

		popup=RunAnalysis(self.parent,(self.filename,self.rsgf_filename),move_selection,intervals,variation,komi,bot,self.existing_variations.get())
		self.parent.add_popup(popup)
		self.close()




import Queue
import time

import ttk


def guess_color_to_play(move_zero,move_number):

	one_move=go_to_move(move_zero,move_number)

	if one_move==False:
		previous_move_color=guess_color_to_play(move_zero,move_number-1)
		if previous_move_color.lower()=='b':
			return "w"
		else:
			return "b"


	player_color,unused=one_move.get_move()
	if player_color != None:
		return player_color

	if one_move is move_zero:
		if node_has(move_zero,"PL"):
			if node_get(move_zero,"PL").lower()=="b":
				return "w"
			if node_get(move_zero,"PL").lower()=="w":
				return "b"
		else:
			return "w"

	previous_move_color=guess_color_to_play(move_zero,move_number-1)

	if previous_move_color.lower()=='b':
		return "w"
	else:
		return "b"

class LiveAnalysisBase():
	def __init__(self,g,rsgf_filename,profile):
		self.g=g
		self.rsgf_filename=rsgf_filename
		self.profile=profile
		self.bot=self.initialize_bot()
		self.update_queue=Queue.PriorityQueue()
		self.label_queue=Queue.Queue()
		self.best_moves_queue=Queue.Queue()

		self.move_zero=self.g.get_root()

		self.no_variation_if_same_move=True

		size=self.g.get_size()
		log("size of the tree:", size)
		self.size=size

		self.no_variation_if_same_move=grp_config.getboolean('Analysis', 'NoVariationIfSameMove')

		self.maxvariations=grp_config.getint("Analysis", "maxvariations")

		self.stop_at_first_resign=False

		self.cpu_lock=threading.Lock()

	def start(self):
		threading.Thread(target=self.run_live_analysis).start()

	def play(self,gtp_color,gtp_move):
		if gtp_color=='w':
			self.bot.place_white(gtp_move)
		else:
			self.bot.place_black(gtp_move)

	def undo(self):
		self.bot.undo()

	def run_live_analysis(self):
		self.current_move=1
		wait=0
		while 1:
			while wait>0:
				time.sleep(0.1)
				wait-=0.1
				try:
					priority,msg=self.update_queue.get(False)
					if priority<1:
						log("Analyser received a high priority message")
						wait=0
					self.update_queue.put((priority,msg))

				except:
					continue


			if not self.cpu_lock.acquire(False):
				time.sleep(2) #let's wait just enough time in case human player already has a move to play
				continue

			try:
				priority,msg=self.update_queue.get(False)
			except:
				self.cpu_lock.release()
				time.sleep(.5)
				continue

			if msg==None:
				log("Leaving the analysis")
				self.cpu_lock.release()
				return

			if msg=="wait":
				log("Analyser iddle for five seconds")
				self.cpu_lock.release()
				wait=5
				continue

			if type(msg)==type("undo xxx"):
				move_to_undo=int(msg.split()[1])
				log("received undo msg for move",move_to_undo,"and beyong")


				log("GTP bot is currently at move",len(self.bot.history))
				while len(self.bot.history)>=move_to_undo:
					log("Undoing move",len(self.bot.history),"through GTP")
					self.undo()
					self.current_move-=1

				log("Deleting the SGF branch")
				parent=go_to_move(self.move_zero,move_to_undo-1)
				new_branch=parent[0]
				old_branch=parent[1]

				for p in ["ES","CBM","BWWR","VNWR", "MCWR","UBS","LBS","C"]:
					if node_has(old_branch,p):
						node_set(new_branch,p,node_get(old_branch,p))

				old_branch.delete()
				write_rsgf(self.rsgf_filename,self.g)
				self.cpu_lock.release()
				self.update_queue.put((0,"wait"))
				self.best_moves_queue.put((priority,msg))#sending echo
				continue

			log("Analyser received msg to analyse move",msg)
			while msg>self.current_move:
				log("Analyser currently at move",self.current_move)
				log("So asking "+self.bot.bot_name+" to play the game move",self.current_move)
				one_move=go_to_move(self.move_zero,self.current_move)
				player_color,player_move=one_move.get_move()
				log("game move",self.current_move,"is",player_color,"at",player_move)
				if player_color in ('w',"W"):
					log("white at",ij2gtp(player_move))
					self.play("w",ij2gtp(player_move))
				else:
					log("black at",ij2gtp(player_move))
					self.play("b",ij2gtp(player_move))
				self.current_move+=1

			log("Analyser is currently at move",self.current_move)
			self.label_queue.put(self.current_move)
			log("starting analysis of move",self.current_move)
			answer=self.run_analysis(self.current_move)
			log("Analyser best move: move %i at %s"%(self.current_move,answer))
			self.best_moves_queue.put([self.current_move,answer])

			try:
				game_move=go_to_move(self.move_zero,self.current_move).get_move()[1]
				log("Game move:",game_move)
				if game_move:
					if self.no_variation_if_same_move:
						if ij2gtp(game_move)==answer:
							log("Bot move and game move are the same ("+answer+"), removing variations for this move")
							parent=go_to_move(self.move_zero,self.current_move-1)
							for child in parent[1:]:
								child.delete()
			except:
				#what could possibly go wrong with this?
				pass

			if self.update_queue.empty():
				self.label_queue.put("")
			write_rsgf(self.rsgf_filename,self.g)
			self.cpu_lock.release()
			#self.current_move+=1
			time.sleep(.1) #enought time for Live analysis to grap the lock






class RunAnalysisBase(Toplevel):
	def __init__(self,parent,filenames,move_range,intervals,variation,komi,profile,existing_variations="remove_everything"):
		if parent!="no-gui":
			Toplevel.__init__(self,parent)
		self.parent=parent
		self.filename=filenames[0]
		self.rsgf_filename=filenames[1]
		self.move_range=move_range
		self.update_queue=Queue.Queue(1)
		self.intervals=intervals
		self.variation=variation
		self.komi=komi
		self.profile=profile
		self.g=None
		self.move_zero=None
		self.current_move=None
		self.time_per_move=None
		self.existing_variations=existing_variations

		self.no_variation_if_same_move=grp_config.getboolean('Analysis', 'NoVariationIfSameMove')

		self.error=None
		try:
			self.g=open_sgf(self.filename)
			self.move_zero=self.g.get_root()
			self.max_move=get_moves_number(self.move_zero)

			if existing_variations=="remove_everything":
				leaves=get_all_sgf_leaves(self.g.get_root())
				log("keeping only variation",self.variation)
				keep_only_one_leaf(leaves[self.variation][0])
			else:
				log("analysis will be performed on first variation")
				if existing_variations=="keep":
					move=1
					log("checking for moves already analysed")
					already_analysed=[]
					while move<=self.max_move:
						if move in self.move_range:
							node=go_to_move(self.move_zero,move)
							if len(node.parent)>1:
								already_analysed.append(move)
						move+=1
					log("The following moves are already analysed and will be skipped")
					log(already_analysed)
					for move in already_analysed:
						self.move_range.remove(move)
					if not self.move_range:
						self.move_range=["empty"]

			size=self.g.get_size()
			log("size of the tree:", size)
			self.size=size

			log("Setting new komi")
			node_set(self.g.get_root(),"KM",self.komi)
		except Exception,e:
			self.error=unicode(e)
			self.abort()
			return


		try:
			self.bot=self.initialize_bot()
		except Exception,e:
			self.error=_("Error while initializing the GTP bot:")+"\n"+unicode(e)
			self.abort()
			return

		if not self.bot:
			return


		self.total_done=0

		if parent!="no-gui":
			try:
				self.initialize_UI()
			except Exception,e:
				self.error=_("Error while initializing the graphical interface:")+"\n"+unicode(e)
				self.abort()
				return
			self.root.after(500,self.follow_analysis)

		first_comment=_("Analysis by GoReviewPartner")
		first_comment+="\n"+_("Bot")+(": %s/%s"%(self.bot.bot_name,self.bot.bot_version))
		first_comment+="\n"+_("Komi")+(": %0.1f"%self.komi)
		first_comment+="\n"+_("Intervals")+(": %s"%self.intervals)

		if grp_config.getboolean('Analysis', 'SaveCommandLine'):
			first_comment+="\n"+(_("Command line")+": %s"%self.bot.command_line)

		first_comment+="\n"

		node_set(self.move_zero,"RSGF",first_comment)
		node_set(self.move_zero,"BOT",self.bot.bot_name)
		node_set(self.move_zero,"BOTV",self.bot.bot_version)

		self.maxvariations=grp_config.getint("Analysis", "maxvariations")

		try:
			if grp_config.getboolean('Analysis', 'StopAtFirstResign'):
				log("Stop_At_First_Resign is ON")
				self.stop_at_first_resign=True
			else:
				self.stop_at_first_resign=False
				log("Stop_At_First_Resign is OFF")
		except:
			self.stop_at_first_resign=False
			log("Stop_At_First_Resign is OFF")

		#when the game last move is not pass or resign
		#then let's add a pass move and extand the analysis
		#only if the analysis is part of the last move
		if self.max_move in self.move_range:
			last_move=go_to_move(self.move_zero,self.max_move)

			if last_move.get_move()[1]:
				self.move_range.append(max(self.move_range)+1)
				self.g.extend_main_sequence()
				self.max_move+=1

		self.completed=False

		if parent=="no-gui":
			self.run_all_analysis()
		else:
			threading.Thread(target=self.run_all_analysis).start()



	def initialize_bot(self):
		pass

	def run_analysis(self,current_move):
		log("Analysis of move",current_move)
		#################################################
		##### here is the place to perform analysis #####
		#################################################

		log("Analysis for this move is completed")

	def play(self,gtp_color,gtp_move):
		if gtp_color=='w':
			self.bot.place_white(gtp_move)
		else:
			self.bot.place_black(gtp_move)

	def run_all_analysis(self):
		self.current_move=1
				
		while self.current_move<=self.max_move:
			answer=""
			if self.current_move in self.move_range:
				parent=go_to_move(self.move_zero,self.current_move-1)
				if len(parent)>1:
					log("Removing existing",len(parent)-1,"variations")
					for other_leaf in parent[1:]:
						other_leaf.delete()
				answer=self.run_analysis(self.current_move)
				self.total_done+=1
				write_rsgf(self.rsgf_filename,self.g)
				log("For this position,",self.bot.bot_name,"would play:",answer)
				log("Analysis for this move is completed")
			elif self.move_range:
				log("Move",self.current_move,"not in the list of moves to be analysed, skipping")

			try:
				game_move=go_to_move(self.move_zero,self.current_move).get_move()[1]
				if game_move:
					if self.no_variation_if_same_move:
						if ij2gtp(game_move)==answer:
							log("Bot move and game move are the same ("+answer+"), removing variations for this move")
							parent=go_to_move(self.move_zero,self.current_move-1)
							for child in parent[1:]:
								child.delete()
							write_rsgf(self.rsgf_filename,self.g)
			except:
				#what could possibly go wrong with this?
				pass

			if (answer=="RESIGN") and (self.stop_at_first_resign==True):
				log("")
				log("The analysis will stop now")
				log("")
				self.move_range=[]
				#the bot has proposed to resign, and resign_at_first_stop is ON
			elif self.move_range:
				one_move=go_to_move(self.move_zero,self.current_move)
				player_color,player_move=one_move.get_move()
				if player_color in ('w',"W"):
					log("now asking "+self.bot.bot_name+" to play the game move: white at",ij2gtp(player_move))
					self.play('w',ij2gtp(player_move))
				else:
					log("now asking "+self.bot.bot_name+" to play the game move: black at",ij2gtp(player_move))
					self.play('b',ij2gtp(player_move))

			self.current_move+=1
			if self.parent!="no-gui":
				self.update_queue.put(self.total_done)
		return

	def abort(self):
		try:
			self.lab1.config(text=_("Aborted"))
			self.lab2.config(text="")
		except:
			pass
		log("Leaving follow_anlysis()")
		show_error(_("Analysis aborted:")+"\n\n"+self.error,parent=self)

	def follow_analysis(self):

		if self.error:
			self.abort()
			return
		msg=None
		try:
			msg=self.update_queue.get(False)
			if self.total_done>0:
				self.time_per_move=1.0*(time.time()-self.t0)/self.total_done+1
				#log(self.total_done,"move(s) analysed in",int(10*(time.time()-self.t0))/10.,"secondes =>",int(10*self.time_per_move)/10.,"s/m")
				#log("self.time_per_move=",(time.time()-self.t0),"/",self.total_done,"=",self.time_per_move)
			remaining_s=int((len(self.move_range)-self.total_done)*self.time_per_move)
			remaining_h=remaining_s/3600
			remaining_s=remaining_s-3600*remaining_h
			remaining_m=remaining_s/60
			remaining_s=remaining_s-60*remaining_m
			if self.time_per_move!=0:
				self.lab2.config(text=_("Remaining time: %ih, %im, %is")%(remaining_h,remaining_m,remaining_s))
			self.lab1.config(text=_("Currently at move %i/%i")%(self.current_move,self.max_move))

			self.pb.update_idletasks()
			if msg==1:#msg contains the value of self.total_done
				if not self.review_button:
					self.review_button=Button(self.right_frame,text=_("Start the review"),command=self.start_review)
					self.review_button.pack()
		except:
			pass

		if self.current_move<=self.max_move:
			if msg==None:
				self.parent.after(250,self.follow_analysis)
			else:
				self.pb.step()
				self.parent.after(10,self.follow_analysis)
		else:
			self.end_of_analysis()

	def end_of_analysis(self):
		self.lab1.config(text=_("Completed"))
		self.lab2.config(text="")
		self.pb["maximum"] = 100
		self.pb["value"] = 100

	def start_review(self):
		import dual_view
		app=self.parent
		popup=dual_view.DualView(app,self.rsgf_filename)
		self.parent.add_popup(popup)
		if (self.pb["maximum"] == 100) and (self.pb["value"] == 100):
			self.close()

	def terminate_bot(self):
		try:
			log("killing",self.bot.bot_name)
			self.bot.close()
		except Exception,e:
			log(e)
	def remove_app(self):
		log("RunAnalysis beeing closed")
		self.lab2.config(text=_("Now closing, please wait..."))
		self.update_idletasks()
		try:
			self.terminate_bot()
		except:
			pass
		self.destroy()

	def close(self):
		self.remove_app()
		self.destroy()
		self.parent.remove_popup(self)
		log("RunAnalysis closed")
		self.completed=True

	def initialize_UI(self):


		if not self.move_range:
			self.move_range=range(1,self.max_move+1)



		root = self
		root.title('GoReviewPartner')
		root.protocol("WM_DELETE_WINDOW", self.close)

		bg=root.cget("background")
		logo = Canvas(root,bg=bg,width=5,height=5)
		logo.pack(fill=BOTH,expand=1,side=LEFT)
		logo.bind("<Configure>",lambda e: draw_logo(logo,e,"vertical"))

		right_frame=Frame(root)
		right_frame.pack(side=LEFT,padx=5, pady=5)
		self.right_frame=right_frame
		Label(right_frame,text=_("Analysis of: %s")%os.path.basename(self.filename)).pack()

		self.lab1=Label(right_frame)
		self.lab1.pack()

		self.lab2=Label(right_frame)
		self.lab2.pack()

		self.lab1.config(text=_("Currently at move %i/%i")%(1,self.max_move))

		self.pb = ttk.Progressbar(right_frame, orient="horizontal", length=250,maximum=self.max_move+1, mode="determinate")
		self.pb.pack()

		try:
			write_rsgf(self.rsgf_filename,self.g)
		except Exception,e:
			self.lab1.config(text=_("Aborted"))
			self.lab2.config(text="")
			raise e

		self.t0=time.time()

		self.root=root
		self.review_button=None



class BotOpenMove():
	def __init__(self,sgf_g,profile):
		self.name='Bot'
		self.bot=None
		self.okbot=False
		self.sgf_g=sgf_g
		self.profile=profile

	def start(self,silentfail=True):
		try:
			result=self.my_starting_procedure(self.sgf_g,profile=self.profile,silentfail=silentfail)
			if result:
				self.bot=result
				self.okbot=True
			else:
				self.okbot=False
		except Exception, e:
			log("Could not launch "+self.name)
			log(e)
			self.okbot=False
		return

	def undo(self):
		if self.okbot:
			self.bot.undo()

	def place(self,move,color):
		if self.okbot:
			if not self.bot.place(move,color):
				#self.config(state='disabled')
				return False
			return True

	def quick_evaluation(self,color):
		return self.bot.quick_evaluation(color)

	def click(self,color):
		log(self.name,"play")
		n0=time.time()
		if color==1:
			move=self.bot.play_black()
		else:
			move=self.bot.play_white()
		log("move=",move,"in",time.time()-n0,"s")
		return move

	def close(self):
		if self.okbot:
			log("killing",self.name)
			self.bot.close()

def bot_starting_procedure(bot_name,bot_gtp_name,bot_gtp,sgf_g,profile,silentfail=False):

	log("Bot starting procedure started with profile =",profile["profile"])
	log("\tbot name:",bot_name)
	log("\tbot gtp name",bot_gtp_name)

	command_entry=profile["command"]
	parameters_entry=profile["parameters"]

	size=sgf_g.get_size()

	try:

		log("Starting "+bot_name+"...")
		try:
			#bot_command_line=[grp_config.get(bot_name, command_entry)]+grp_config.get(bot_name, parameters_entry).split()
			bot_command_line=[command_entry]+parameters_entry.split()
			bot=bot_gtp(bot_command_line)
		except Exception,e:
			raise GRPException((_("Could not run %s using the command from config.ini file:")%bot_name)+"\n"+command_entry+" "+parameters_entry+"\n"+unicode(e))

		log(bot_name+" started")
		log(bot_name+" identification through GTP...")
		try:
			answer=bot.name()
		except Exception, e:
			raise GRPException((_("%s did not reply as expected to the GTP name command:")%bot_name)+"\n"+unicode(e))

		if bot_gtp_name!='GtpBot':
			if answer!=bot_gtp_name:
				raise GRPException((_("%s did not identify itself as expected:")%bot_name)+"\n'"+bot_gtp_name+"' != '"+answer+"'")
		else:
			bot_gtp_name=answer

		log(bot_name+" identified itself properly")
		log("Checking version through GTP...")
		try:
			bot_version=bot.version()
		except Exception, e:
			raise GRPException((_("%s did not reply as expected to the GTP version command:")%bot_name)+"\n"+unicode(e))

		log("Version: "+bot_version)
		log("Setting goban size as "+str(size)+"x"+str(size))
		try:
			ok=bot.boardsize(size)
		except:
			raise GRPException((_("Could not set the goboard size using GTP command. Check that %s is running in GTP mode.")%bot_name))

		if not ok:
			raise GRPException(_("%s rejected this board size (%ix%i)")%(bot_name,size,size))


		log("Clearing the board")
		bot.reset()

		log("Checking for existing stones or handicap stones on the board")
		gameroot=sgf_g.get_root()
		if node_has(gameroot,"HA"):
			nb_handicap=node_get(gameroot,"HA")
			log("The SGF indicates",nb_handicap,"stone(s)")
		else:
			nb_handicap=0
			log("The SGF does not indicate handicap stone")
		#import pdb; pdb.set_trace()
		board, unused = sgf_moves.get_setup_and_moves(sgf_g)
		nb_occupied_points=len(board.list_occupied_points())
		log("The SGF indicates",nb_occupied_points,"occupied point(s)")

		free_handicap_black_stones_positions=[]
		already_played_black_stones_position=[]
		already_played_white_stones_position=[]

		for color, move in board.list_occupied_points():
			if move != None:
				row, col = move
				move=ij2gtp((row,col))
				if color.lower()=='b':
					if nb_handicap>0:
						free_handicap_black_stones_positions.append(move)
						nb_handicap-=1
					else:
						already_played_black_stones_position.append(move)
				else:
					already_played_white_stones_position.append(move)

		if len(free_handicap_black_stones_positions)>0:
			log("Setting handicap stones at"," ".join(free_handicap_black_stones_positions))
			bot.set_free_handicap(free_handicap_black_stones_positions)

		for stone in already_played_black_stones_position:
			log("Adding a black stone at",stone)
			bot.place_black(stone)

		for stone in already_played_white_stones_position:
			log("Adding a white stone at",stone)
			bot.place_white(stone)

		log("Setting komi at",sgf_g.get_komi())
		bot.komi(sgf_g.get_komi())

		log(bot_name+" initialization completed")

		bot.bot_name=bot_gtp_name
		bot.bot_version=bot_version
	except Exception,e:
		if silentfail:
			log(e)
		else:
			show_error(unicode(e))
		return False
	return bot



def draw_logo(logo,event=None,stretch="horizontal"):

	for item in logo.find_all():
		logo.delete(item)

	width=event.width
	height=event.height

	if stretch=="horizontal":
		logo.config(height=width)
	else:
		logo.config(width=height)

	border=0.1
	w=width*(1-2*border)
	b=width*border

	for u in [1/4.,2/4.,3/4.]:
		for v in [1/4.,2/4.,3/4.]:
			x1=b+w*(u-1/8.)
			y1=b+w*(v-1/8.)
			x2=b+w*(u+1/8.)
			y2=b+w*(v+1/8.)

			logo.create_oval(x1, y1, x2, y2, fill="#ADC5E7", outline="")

	for k in [1/4.,2/4.,3/4.]:
		x1=b+k*w
		y1=b
		x2=x1
		y2=b+w
		logo.create_line(x1, y1, x2, y2, width=w*7/318., fill="#21409A")
		logo.create_line(y1, x1, y2, x2, width=w*7/318., fill="#21409A")

	for u,v in [(2/4.,1/4.),(3/4.,2/4.),(1/4.,3/4.),(2/4.,3/4.),(3/4.,3/4.)]:
		x1=b+w*(u-1/8.)
		y1=b+w*(v-1/8.)
		x2=b+w*(u+1/8.)
		y2=b+w*(v+1/8.)

		logo.create_oval(x1, y1, x2, y2, fill="black", outline="")

import __main__
try:
	usage="usage: python "+__main__.__file__+" [--range=<range>] [--color=<both|black|white>] [--komi=<komi>] [--variation=<variation>] [--profil=<\"profil\">] [--no-gui] <sgf file1> <sgf file2> <sgf file3>"
except:
	log("Command line features are disabled")
	usage=""

def parse_command_line(filename,argv):
	g=open_sgf(filename)

	move_zero=g.get_root()

	leaves=get_all_sgf_leaves(move_zero)

	found=False

	#argv=[(unicode(p,errors="replace"),unicode(v,errors="replace")) for p,v in argv] #ok, this is maybe overkill...
	for p,v in argv:
		if p=="--variation":
			try:
				variation=int(v)
				found=True
			except:
				show_error("Wrong variation parameter\n"+usage)
				sys.exit()
	if not found:
		variation=1

	log("Variation:",variation)

	if variation<1:
		show_error("Wrong variation parameter, it must be a positive integer")
		sys.exit()

	if variation>len(leaves):
		show_error("Wrong variation parameter, this SGF file has only "+str(len(leaves))+" variation(s)")
		sys.exit()

	nb_moves=leaves[variation-1][1]
	log("Moves for this variation:",nb_moves)

	if nb_moves==0:
		show_error("This variation is empty (0 move), the analysis cannot be performed!")
		sys.exit()

	#nb_moves=get_moves_number(move_zero)

	found=False
	for p,v in argv:
		if p=="--range":
			if v=="":
				show_error("Wrong range parameter\n"+usage)
				sys.exit()
			elif v=="all":
				break
			else:
				intervals=v
				log("Range:",v)
				move_selection=check_selection(v.replace('"',''),nb_moves)
				if move_selection==False:
					show_error("Wrong range parameter\n"+usage)
					sys.exit()
				found=True
				break

	if not found:
		move_selection=range(1,nb_moves+1)
		intervals="all moves"
		log("Range: all")

	found=False
	for p,v in argv:
		if p=="--color":

			if v in ["black","white"]:
				log("Color:",v)
				move_selection=check_selection_for_color(move_zero,move_selection,v)
				intervals+=" ("+v+"only)"
				found=True
				break
			elif v=="both":
				break
			else:
				show_error("Wrong color parameter\n"+usage)
				sys.exit()
	if not found:
		intervals+=" (both colors)"
		log("Color: both")

	found=False
	for p,v in argv:
		if p=="--komi":
			try:
				komi=float(v)
				found=True
			except:
				show_error("Wrong komi parameter\n"+usage)
				sys.exit()
	if not found:
		try:
			komi=g.get_komi()
		except Exception, e:
			msg="Error while reading komi value, please check:\n"+unicode(e)
			msg+="\nPlease indicate komi using --komi parameter"
			log(msg)
			show_error(msg)
			sys.exit()

	log("Komi:",komi)

	found=False
	for p,v in argv:
		if p=="--profile":
			profile=v
			found=True
	if not found:
		profile=None
	log("Profile:",profile)

	nogui=False
	for p,v in argv:
		if p=="--no-gui":
			nogui=True
			break

	return move_selection,intervals,variation,komi,nogui,profile

# from http://www.py2exe.org/index.cgi/WhereAmI
def we_are_frozen():
	"""Returns whether we are frozen via py2exe.
	This will affect how we find out where we are located."""

	return hasattr(sys, "frozen")


def module_path():
	""" This will get us the program's directory,
	even if we are frozen using py2exe"""

	if we_are_frozen():
		log("Apparently running from the executable.")
		return os.path.dirname(unicode(sys.executable, sys.getfilesystemencoding( )))

	return os.path.dirname(unicode(__file__, sys.getfilesystemencoding( )))



try:
	pathname=module_path()
except:
	pathname=os.path.dirname(__file__)

log('GRP path:', os.path.abspath(pathname))
config_file=os.path.join(os.path.abspath(pathname),"config.ini")
log('Config file:', config_file)

import ConfigParser
log("Checking availability of config file")
conf = ConfigParser.ConfigParser()
try:
	conf.readfp(codecs.open(config_file,"r","utf-8"))
except Exception, e:
	show_error("Could not open the config file of Go Review Partner"+"\n"+unicode(e)) #this cannot be translated
	sys.exit()

class MyConfig():
	def __init__(self,config_file):
		self.config = ConfigParser.ConfigParser()
		self.config.read(config_file)
		self.config_file=config_file

		self.default_values={}
		self.default_values["general"]={}
		self.default_values["general"]["language"]=""
		self.default_values["general"]["sgffolder"]=""
		self.default_values["general"]["rsgffolder"]=""
		self.default_values["general"]["pngfolder"]=""
		self.default_values["general"]["livefolder"]=""
		self.default_values["general"]["stonesound"]=""

		self.default_values["analysis"]={}
		self.default_values["analysis"]["maxvariations"]="26"
		self.default_values["analysis"]["savecommandline"]="False"
		self.default_values["analysis"]["stopatfirstresign"]="False"
		self.default_values["analysis"]["novariationifsamemove"]="False"
		self.default_values["analysis"]["analyser"]=""

		self.default_values["review"]={}
		self.default_values["review"]["fuzzystoneplacement"]="0.2"
		self.default_values["review"]["realgamesequencedeepness"]="5"
		self.default_values["review"]["leftgobanratio"]="0.4"
		self.default_values["review"]["rightgobanratio"]="0.4"
		self.default_values["review"]["rightpanelratio"]="0.4"
		self.default_values["review"]["opengobanratio"]="0.4"
		self.default_values["review"]["maxvariations"]="26"
		self.default_values["review"]["variationscoloring"]="blue_for_winning"
		self.default_values["review"]["variationslabel"]="letter"
		self.default_values["review"]["invertedmousewheel"]="False"
		self.default_values["review"]["lastgraph"]=""
		self.default_values["review"]["yellowbar"]="#F39C12"
		self.default_values["review"]["lastbot"]=""
		self.default_values["review"]["lastmap"]=""
		self.default_values["review"]["oneortwopanels"]="1"

		self.default_values["live"]={}
		self.default_values["live"]["livegobanratio"]="0.4"
		self.default_values["live"]["size"]="19"
		self.default_values["live"]["komi"]="7.5"
		self.default_values["live"]["handicap"]="0"
		self.default_values["live"]["nooverlap"]="False"
		self.default_values["live"]["analyser"]=""
		self.default_values["live"]["black"]=""
		self.default_values["live"]["white"]=""
		self.default_values["live"]["thinkbeforeplaying"]="0"

	def set(self, section, key, value):
		if type(value) in (type(1), type(0.5), type(True)):
			value=unicode(value)
		if type(section)!=type(u"abc"):
			print section, "Warning: A non utf section string sent to my config:",section
		if type(key)!=type(u"abc"):
			print key,"A non utf key string sent to my config:", key
		if type(value)!=type(u"abc"):
			print value,"A non utf value string sent to my config:",value
		section=unicode(section)
		key=unicode(key)
		value=unicode(value)
		self.config.set(section.encode("utf-8"),key.encode("utf-8"),value.encode("utf-8"))
		self.config.write(open(self.config_file,"w"))

	def get(self,section,key):
		try:
			value=self.config.get(section,key)
			value=value.decode("utf-8")
		except:
			log("Could not read",str(section)+"/"+str(key),"from the config file")
			log("Using default value")
			value=self.default_values[section.lower()][key.lower()]
			self.add_entry(section,key,value)
		return value

	def getint(self,section,key):
		try:
			value=self.config.getint(section,key)
		except:
			log("Could not read",str(section)+"/"+str(key),"from the config file")
			log("Using default value")
			value=self.default_values[section.lower()][key.lower()]
			self.add_entry(section,key,value)
			value=self.config.getint(section,key)
		return value

	def getfloat(self,section,key):
		try:
			value=self.config.getfloat(section,key)
		except:
			log("Could not read",str(section)+"/"+str(key),"from the config file")
			log("Using default value")
			value=self.default_values[section.lower()][key.lower()]
			self.add_entry(section,key,value)
			value=self.config.getfloat(section,key)
		return value

	def getboolean(self,section,key):
		try:
			value=self.config.getboolean(section,key)
		except:
			log("Could not read",str(section)+"/"+str(key),"from the config file")
			log("Using default value")
			value=self.default_values[section.lower()][key.lower()]
			self.add_entry(section,key,value)
			value=self.config.getboolean(section,key)
		return value

	def add_entry(self,section,key,value):
		#normally section/key/value should all be unicode here
		#but just to be sure:
		section=unicode(section)
		key=unicode(key)
		value=unicode(value)
		#then, let's turn every thing in str
		section=section.encode("utf-8")
		key=key.encode("utf-8")
		value=value.encode("utf-8")
		if not self.config.has_section(section):
			log("Adding section",section,"in config file")
			self.config.add_section(section)
		log("Setting",section,"/",key,"in the config file")
		self.config.set(section,key,value)
		self.config.write(open(self.config_file,"w"))

	def get_sections(self):
		return [section.decode("utf-8") for section in self.config.sections()]

	def get_options(self,section):
		return [option.decode("utf-8") for option in self.config.options(section)]

	def remove_section(self,section):
		result=self.config.remove_section(section)
		self.config.write(open(self.config_file,"w"))
		return result

grp_config=MyConfig(config_file)

log("Reading language setting from config file")

lang=grp_config.get("General","Language")


available_translations={"en": "English", "fr" : "Français", "de" : "Deutsch", "kr" : "한국어", "zh": "中文", "pl": "Polski", "ru": "Русский"}
if not lang:
	log("No language setting in the config file")
	log("System language detection:")
	import locale
	try:
		lang=locale.getdefaultlocale()[0].split('_')[0]
		log("System language:",lang,"("+locale.getdefaultlocale()[0]+")")
		if lang in available_translations:
			log("There is a translation available for lang="+lang)
		else:
			log("No translation available for lang="+lang)
			log("Falling back on lang=en")
			lang="en"
	except Exception, e:
		log("Could not determine the system language")
		log(e)
		log("Falling back to english")
		lang="en"
	log("Saving the lang parameter in config.ini")
	grp_config.set("General","Language",lang)
else:
	if lang in available_translations:
		log("lang="+lang)
	else:
		log("Unkonwn language setting in config.ini (lang="+lang+")")
		log("Falling back on lang=en")
		lang="en"
		log("Saving the lang parameter in config.ini")
		grp_config.set("General","Language",lang)


translations={}

def prepare_translations():
	global translations

	if lang=='en':
		return

	data_file_url=os.path.join(os.path.abspath(pathname),"translations",lang+".po")
	log("Loading translation file:",data_file_url)

	data_file = codecs.open(data_file_url,"r","utf-8")
	translation_data=data_file.read()
	data_file.close()

	entry=""
	translation=""

	for line in translation_data.split('\n'):
		line=line.strip()
		key="msgid"
		if line[:len(key)+2]==key+' "':
			entry=line[len(key)+2:-1]
			translation=""

		key="msgstr"
		if line[:len(key)+2]==key+' "':
			translation=line[len(key)+2:-1]
			translation=translation.replace("\\\"","\"")
			if len(entry)>0 and len(translation)>0:
				translations[entry]=translation
			entry=""
			translation=""

prepare_translations()

def _(txt=None):
	global translations
	if not translations:
		return unicode(txt)
	if translations.has_key(txt):
		return translations[txt]
	return unicode(txt)

def batch_analysis(app,batch):
	#there appears to be a Tk 8.6 regression bug that leads to random "Tcl_AsyncDelete: async handler deleted by the wrong thread Abandon (core dumped)"
	#this happens when app=Tk() is detroyed after one analysis, and a new one is created for the next analysis
	#this bug is sidestepped by recycling the same app=Tk() for all analysis
	#see also: http://learning-python.com/python-changes-2014-plus.html#s35E

	try:
		if len(batch)==0:
			app.remove_popup(app)
			return

		app.add_popup(app)
		one_analysis=batch[0]

		if len(one_analysis)==1:
			if one_analysis[0].completed==False:
				app.after(1000,lambda: batch_analysis(app,batch))
			else:
				batch=batch[1:]
				app.after(1,lambda: batch_analysis(app,batch))
		else:
			run,filename,move_selection,intervals,variation,komi,profil=one_analysis
			log("File to analyse:",filename[0])
			log("Output file:",filename[1])
			popup=run(app,filename,move_selection,intervals,variation,komi,profil)
			app.add_popup(popup)
			popup.end_of_analysis=popup.close
			batch[0]=[popup]
			app.after(1,lambda: batch_analysis(app,batch))
	except Exception, e:
		log("Batch analysis failed")
		log(e)
		app.force_close()


def opposite_rate(value):
	return str(100-float(value[:-1]))+"%"

position_data_formating={}
position_data_formating["CBM"]=_("For this position, %s would play: %s")
position_data_formating["B"]=_("Black to play. In the game, black played %s")
position_data_formating["W"]=_("White to play. In the game, white played %s")

def format_data(sgf_property,formating,value="",bot="Bot"):
	txt=formating[sgf_property]
	#print "formating["+sgf_property+"]",txt
	try:
		if sgf_property in ("ES","CBM","BWWR"):
			txt=txt%(bot,value)
	except:
		pass

	try:
		if sgf_property in ("B","W","BWWR","PNV","MCWR","VNWR","PLYO","EVAL","RAVE","UBS","LBS"):
			txt=txt%(value)
	except:
		pass

	try:
		if sgf_property in ("BKMV",):
			txt=txt
	except:
		pass

	return txt

variation_data_formating={}
variation_data_formating["ES"]=_("Score estimation for this variation: %s")
variation_data_formating["BWWR"]=_("black/white win probability for this variation: %s")
variation_data_formating["BKMV"]=_("Book move")
variation_data_formating["PNV"]=_("Policy network value for this variation: %s")
variation_data_formating["MCWR"]=_("Monte Carlo win probability for this variation: %s")
variation_data_formating["VNWR"]=_("Value network black/white win probability for this variation: %s")
variation_data_formating["PLYO"]=_("Number of playouts used to estimate this variation: %s")
variation_data_formating["EVAL"]=_("Evaluation for this variation: %s")
variation_data_formating["RAVE"]=_("RAVE(x%% : y) for this variation: %s")

def save_position_data(node,sgf_property,value):
	log("WARNING: save_position_data() still in used...")
	node_set(node,sgf_property,value)

def save_variation_data(node,sgf_property,value):
	log("WARNING: save_variation_data() still in used...")
	node_set(node,sgf_property,value)

class Application(Tk):
	def __init__(self):
		Tk.__init__(self)
		self.popups=[]
		self.title('GoReviewPartner')
		try:
			ico = Image("photo", file="icon.gif")
			self.tk.call('wm', 'iconphoto', str(self), '-default', ico)
		except:
			log("(Could not load the application icon)")
		self.withdraw()

	def force_close(self):
		os._exit(0)

	def remove_popup(self,popup):
		log("Removing popup")
		self.popups.remove(popup)
		log("Totally",len(self.popups),"popups left")
		if len(self.popups)==0:
			try:
				self.destroy()
			except:
				pass
			time.sleep(2)
			log("")
			log("GoReviewPartner is closing")
			log("Hope you enjoyed the experience!")
			log("")
			log("List of contributors")

			contributors_file_url=os.path.join(os.path.abspath(pathname),"AUTHORS")
			contributors_file = codecs.open(contributors_file_url,"r","utf-8")
			contributors=contributors_file.read()
			contributors_file.close()

			for line in contributors.split('\n'):
				if not line:
					continue
				if line[0]=="#":
					continue
				log("\t",line)
			log("")
			log("You are welcome to support GoReviewPartner (bug reports, code fixes, translations, ideas...). If you are interested, get in touch through Github, Reddit, or LifeIn19x19!")
			if we_are_frozen():
				#running from py2exe
				time.sleep(2)
			self.force_close()

	def add_popup(self,popup):
		if popup not in self.popups:
			log("Adding new popup")
			self.popups.append(popup)
			log("Totally",len(self.popups),"popups")


try:

	if "linux" not in sys.platform:
		raise Exception("Avoiding wx")
	import wx
	wxApp = wx.App(None)

	def open_all_file(parent,config,filetype):
		initialdir = grp_config.get(config[0],config[1])
		dialog = wx.FileDialog(None,_('Select a file'), defaultDir=initialdir, wildcard=filetype, style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
		filename = None
		if dialog.ShowModal() == wx.ID_OK:
			filename = dialog.GetPath()
		dialog.Destroy()
		if filename:
			initialdir=os.path.dirname(filename)
			grp_config.set(config[0],config[1],initialdir)
		return filename

	def open_sgf_file(parent=None):
		wildcard=_("SGF file")+" (*.sgf;*.SGF)|*.sgf;*.SGF;|"+_("Reviewed SGF file")+" (*.rsgf;*.RSGF)|*.rsgf;*.RSGF"
		return open_all_file(parent,config=("General","sgffolder"),filetype= wildcard)
	def open_rsgf_file(parent=None):
		wildcard=_("Reviewed SGF file")+" (*.rsgf;*.RSGF)|*.rsgf;*.RSGF"
		return open_all_file(parent,config=("General","rsgffolder"),filetype=wildcard)

	def save_all_file(filename, parent, config, filetype):
		initialdir = grp_config.get(config[0],config[1])
		dialog = wx.FileDialog(None,_('Choose a filename'), defaultDir=initialdir,defaultFile=filename, wildcard=filetype[0]+" "+filetype[1], style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
		filename = None
		if dialog.ShowModal() == wx.ID_OK:
			filename = dialog.GetPath()
		dialog.Destroy()
		if filename:
			initialdir=os.path.dirname(filename)
			grp_config.set(config[0],config[1],initialdir)
		return filename

	def save_png_file(filename, parent=None):
		return save_all_file(filename, parent, config=("General","pngfolder"), filetype=(_("PNG image"),"(*.png;*.PNG)|*.png;*.PNG"))

	def save_live_game(filename, parent=None):
		return save_all_file(filename, parent, config=("General","livefolder"), filetype=(_("SGF file"),"(*.sgf;*.SGF)|*.sgf;*.SGF"))


except Exception, e:
	print "Could not import the WX GUI library, please double check it is installed:"
	log(e)
	log("=> No problem, falling back to tkFileDialog")

	def open_all_file(parent,config,filetype):
		import tkFileDialog
		initialdir = grp_config.get(config[0],config[1])
		filename=tkFileDialog.askopenfilename(initialdir=initialdir, parent=parent,title=_("Select a file"),filetypes =filetype )
		if filename:
			initialdir=os.path.dirname(filename)
			grp_config.set(config[0],config[1],initialdir)
		filename=unicode(filename)
		return filename

	def open_sgf_file(parent=None):
		return open_all_file(parent,config=("General","sgffolder"),filetype=[(_('SGF file'), '.sgf'),(_('Reviewed SGF file'), '.rsgf')])

	def open_rsgf_file(parent=None):
		return open_all_file(parent,config=("General","rsgffolder"),filetype=[(_('Reviewed SGF file'), '.rsgf')])

	def save_all_file(filename, parent,config,filetype):
		import tkFileDialog
		initialdir = grp_config.get(config[0],config[1])
		filename=tkFileDialog.asksaveasfilename(initialdir=initialdir, parent=parent,title=_('Choose a filename'),filetypes = [(filetype[0], filetype[1])],initialfile=filename)
		if filename:
			initialdir=os.path.dirname(filename)
			grp_config.set(config[0],config[1],initialdir)
		return filename

	def save_png_file(filename, parent=None):
		return save_all_file(filename, parent, config=("General","pngfolder"), filetype=(_('PNG image'), '.png'))

	def save_live_game(filename, parent=None):
		return save_all_file(filename, parent, config=("General","livefolder"), filetype=(_('SGF file'), '.sgf'))



import mss
import mss.tools
def canvas2png(goban,filename):
	top = goban.winfo_rooty()
	left = goban.winfo_rootx()
	width = goban.winfo_width()
	height = goban.winfo_height()
	try:
		dim=goban.dim
		space=goban.space
		current_tab_id=goban.parent.right_notebook.index("current")
		goban.parent.right_notebook.select(0)
		goban.parent.update_idletasks()
		goban.parent.right_notebook.select(current_tab_id)
		goban.parent.update_idletasks()
		top = goban.winfo_rooty()
		v_center=top+goban.anchor_y+space*(dim+3)/2
		h_center=left+goban.anchor_x+space*(dim+3)/2
		monitor = {'top': int(v_center-space*(dim+3)/2)+1, 'left': int(h_center-space*(dim+3)/2)+1, 'width': int(space*(dim+3))-2, 'height': int(space*(dim+3))-2}
	except:
		monitor = {'top': int(top), 'left': int(left), 'width': int(width), 'height': int(height)}

	goban.after(500,lambda: screenshot(monitor, filename))

def screenshot(monitor, filename):
	log("Screenshot!")
	log(monitor)
	sct_img = mss.mss().grab(monitor)
	mss.tools.to_png(sct_img.rgb, sct_img.size, output=filename)

def get_variation_comments(one_variation):
	comments=''
	for sgf_property in ("BWWR","PNV","MCWR","VNWR","PLYO","EVAL","RAVE","ES","BKMV"):
		if node_has(one_variation,sgf_property):
			comments+=format_data(sgf_property,variation_data_formating,node_get(one_variation,sgf_property))+"\n"
	return comments

def get_position_comments(current_move,gameroot):
	comments=""
	if current_move==1:
		if node_has(gameroot,"RSGF"):
			comments+=node_get(gameroot,"RSGF")
		if node_has(gameroot,"PB"):
			comments+=_("Black")+": "+node_get(gameroot,"PB")+"\n"
		if node_has(gameroot,"PW"):
			comments+=_("White")+": "+node_get(gameroot,"PW")+"\n"

		if comments:
			comments+="\n"

	comments+=_("Move %i")%current_move
	game_move_color,game_move=get_node(gameroot,current_move).get_move()

	if not game_move_color:
		game_move_color=guess_color_to_play(gameroot,current_move)

	if game_move_color.lower()=="w":
		comments+="\n"+(position_data_formating["W"])%ij2gtp(game_move)
	elif game_move_color.lower()=="b":
		comments+="\n"+(position_data_formating["B"])%ij2gtp(game_move)

	node=get_node(gameroot,current_move)
	if node_has(node,"CBM"):
		bot=node_get(gameroot,"BOT")
		comments+="\n"+(position_data_formating["CBM"])%(bot,node_get(node,"CBM"))
		try:
			if node_has(node[1],"BKMV"):
				if node_get(node[1],"BKMV")=="yes":
					comments+=" ("+variation_data_formating["BKMV"]+")"
		except:
			pass
	try:
		if node_has(node,"BWWR"):
			if node_has(node[0],"BWWR"):
				if node.get_move()[0].lower()=="b":
					comments+="\n\n"+_("Black win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"BWWR").split("/")[0]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"BWWR").split("/")[0]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"BWWR").split("%/")[0])-float(node_get(node,"BWWR").split("%/")[0]))
				else:
					comments+="\n\n"+_("White win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"BWWR").split("/")[1]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"BWWR").split("/")[1]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"BWWR").split("%/")[1][:-1])-float(node_get(node,"BWWR").split("%/")[1][:-1]))
	except:
		pass

	try:
		if node_has(node,"VNWR"):
			if node_has(node[0],"VNWR"):
				if node.get_move()[0].lower()=="b":
					comments+="\n\n"+_("Black Value Network win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"VNWR").split("/")[0]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"VNWR").split("/")[0]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"VNWR").split("%/")[0])-float(node_get(node,"VNWR").split("%/")[0]))
				else:
					comments+="\n\n"+_("White Value Network win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"VNWR").split("/")[1]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"VNWR").split("/")[1]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"VNWR").split("%/")[1][:-1])-float(node_get(node,"VNWR").split("%/")[1][:-1]))
	except:
		pass

	try:
		if node_has(node,"MCWR"):
			if node_has(node[0],"MCWR"):
				if node.get_move()[0].lower()=="b":
					comments+="\n\n"+_("Black Monte Carlo win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"MCWR").split("/")[0]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"MCWR").split("/")[0]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"MCWR").split("%/")[0])-float(node_get(node,"MCWR").split("%/")[0]))
				else:
					comments+="\n\n"+_("White Monte Carlo win probability:")
					comments+="\n • "+(_("before %s")%ij2gtp(game_move))+": "+node_get(node,"MCWR").split("/")[1]
					comments+="\n • "+(_("after %s")%ij2gtp(game_move))+": "+node_get(node[0],"MCWR").split("/")[1]
					comments+=" (%+.2fpp)"%(float(node_get(node[0],"MCWR").split("%/")[1][:-1])-float(node_get(node,"MCWR").split("%/")[1][:-1]))
	except:
		pass

	return comments

def get_position_short_comments(current_move,gameroot):
	# One line comment
	comments=""

	node=get_node(gameroot,current_move)
	game_move_color,game_move=node.get_move()

	if not game_move_color:
		game_move_color=guess_color_to_play(gameroot,current_move)
	comments+="%i/%i: "%(current_move,get_node_number(gameroot))

	if node_has(node,"BWWR"):
		comments+=node_get(node,"BWWR")+"\n"
	elif node_has(node,"VNWR"):
		comments+=node_get(node,"VNWR")+"\n"
	elif node_has(node,"MCWR"):
		comments+=node_get(node,"MCWR")+"\n"
	elif node_has(node,"ES"):
		comments+=node_get(node,"ES")+"\n"
	else:
		comments+="\n"

	comments+="\n"
	if game_move_color.lower()=="b":
		if node_has(gameroot,"PB"):
			player=node_get(gameroot,"PB")
		else:
			player=_("Black")
	else:
		if node_has(gameroot,"PW"):
			player=node_get(gameroot,"PW")
		else:
			player=_("White")

	comments+="%s: %s"%(player,ij2gtp(game_move))

	if node_has(node,"CBM"):
		bot=node_get(gameroot,"BOT")
		comments+="\n%s: %s"%(bot,node_get(node,"CBM"))
		try:
			if node_has(node[1],"BKMV"):
				if node_get(node[1],"BKMV")=="yes":
					comments+=": "+_("Book move")
		except:
			pass
	else:
		comments+="\n"
	return comments

def get_node_number(node):
	return get_moves_number(node)

def get_node(root,number=0):
	if number==0:return root
	node=root
	k=0
	while k!=number:
		if not node:
			return False
		node=node[0]
		k+=1
	return node

def node_set(node, property_name, value):
	if type(value)==type(u"abc"):
		value=value.encode("utf-8")
	if property_name.lower() in ("w","b"):
		node.set_move(property_name.encode("utf-8"),value)
	elif  property_name.upper() in ("TBM","TWM", "IBM", "IWM"):
		new_list=[]
		for ij in value:
			new_list.append(ij2sgf(ij).encode("utf-8"))
		if type(property_name)==type(u"abc"):
			property_name=property_name.encode("utf-8")
		node.set_raw_list(property_name,new_list)
	else:
		if type(property_name)==type(u"abc"):
			property_name=property_name.encode("utf-8")
		node.set(property_name,value)


def node_get(node, property_name):
	if type(property_name)==type(u"abc"):
		property_name=property_name.encode("utf-8")
	value=node.get(property_name)
	if type(value)==type(str("abc")):
		value=value.decode("utf-8")
	return value

def node_has(node, property_name):
	if type(property_name)==type(u"abc"):
		property_name=property_name.encode("utf-8")
	return node.has_property(property_name)

def get_available():
	from leela_analysis import Leela
	from gnugo_analysis import GnuGo
	from ray_analysis import Ray
	from aq_analysis import AQ
	from leela_zero_analysis import LeelaZero
	from pachi_analysis import Pachi
	from phoenixgo_analysis import PhoenixGo

	bots=[]
	for bot in [Leela, AQ, Ray, GnuGo, LeelaZero, Pachi, PhoenixGo]:
		profiles=get_bot_profiles(bot["name"])
		for profile in profiles:
			bot2=dict(bot)
			bots.append(bot2)
			for key, value in profile.items():
				bot2[key]=value
	return bots

def get_gtp_bots():
	from gtp_bot import GtpBot

	bots=[]
	for bot in [GtpBot]:
		profiles=get_bot_profiles(bot["name"])
		for profile in profiles:
			bot2=dict(bot)
			bots.append(bot2)
			for key, value in profile.items():
				bot2[key]=value
	return bots

def get_bot_profiles(bot="",withcommand=True):
	sections=grp_config.get_sections()
	if bot!="":
		bots=[bot]
	else:
		bots=["Leela","GnuGo","Ray","AQ","LeelaZero","Pachi","PhoenixGo"]
	profiles=[]
	for section in sections:
		for bot in bots:
			if bot+"-" in section:
				command=grp_config.get(section,"command")
				if (not command) and (withcommand==True):
					continue
				data={"bot":bot,"command":"","parameters":"","timepermove":"","variations":"4","deepness":"4"}
				for option in grp_config.get_options(section):
					value=grp_config.get(section,option)
					data[option]=value
				profiles.append(data)

	return profiles

class BotProfiles(Frame):
	def __init__(self,parent,bot):
		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+=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

	def clear_selection(self):
		self.index=-1
		self.profile.set("")
		self.command.set("")
		self.parameters.set("")

	def change_selection(self):
		try:
			index=int(self.listbox.curselection()[0])
			self.index=index
			log("Profile",index,"selected")
		except:
			log("No selection")
			self.clear_selection()
			return
		data=self.profiles[index]
		self.profile.set(data["profile"])
		self.command.set(data["command"])
		self.parameters.set(data["parameters"])

	def empty_profiles(self):
		profiles=self.profiles
		sections=grp_config.get_sections()
		for bot in [profile["bot"] for profile in profiles]:
			for section in sections:
				if bot+"-" in section:
					grp_config.remove_section(section)
		self.update_listbox()

	def create_profiles(self):
		profiles=self.profiles
		p=0
		for profile in profiles:
			bot=profile["bot"]
			for key,value in profile.items():
				if key!="bot":
					grp_config.add_entry(bot+"-"+str(p),key,value)
			p+=1
		self.update_listbox()

	def add_profile(self):
		profiles=self.profiles
		if self.profile.get()=="":
			return
		data={"bot":self.bot}
		data["profile"]=self.profile.get()
		data["command"]=self.command.get()
		data["parameters"]=self.parameters.get()
		self.empty_profiles()
		profiles.append(data)
		self.create_profiles()
		self.clear_selection()


	def modify_profile(self):
		profiles=self.profiles
		if self.profile.get()=="":
			return

		if self.index<0:
			log("No selection")
			return
		index=self.index

		profiles[index]["profile"]=self.profile.get()
		profiles[index]["command"]=self.command.get()
		profiles[index]["parameters"]=self.parameters.get()

		self.empty_profiles()
		self.create_profiles()
		self.clear_selection()

	def delete_profile(self):
		profiles=self.profiles

		if self.index<0:
			log("No selection")
			return
		index=self.index

		self.empty_profiles()
		del profiles[index]
		self.create_profiles()
		self.clear_selection()


	def update_listbox(self):
		profiles=self.profiles
		self.listbox.delete(0, END)
		for item in [profile["bot"]+" - "+profile["profile"] for profile in profiles]:
			self.listbox.insert(END, item)

from sys import argv
import getopt
def main(bot):
	if len(argv)==1:
		temp_root = Tk()
		filename = open_sgf_file(parent=temp_root)
		temp_root.destroy()
		log(filename)
		log("gamename:",filename[:-4])
		if not filename:
			sys.exit()
		log("filename:",filename)

		top = Application()


		bots=[]
		profiles=get_bot_profiles(bot["name"])
		for profile in profiles:
			bot2=dict(bot)
			for key, value in profile.items():
				bot2[key]=value
			bots.append(bot2)
		if len(bots)>0:
			popup=RangeSelector(top,filename,bots=bots)
			top.add_popup(popup)
			top.mainloop()
		else:
			log("Not profiles available for "+bot["name"]+" in \"config.ini\"")
	else:
		existing_profiles=[p["profile"] for p in get_bot_profiles(bot["name"])]
		if not existing_profiles:
			log("Not profiles available for "+bot["name"]+" in config.ini")
			sys.exit()
		try:
			parameters=getopt.getopt(argv[1:], '', ['no-gui','range=', 'color=', 'komi=',"variation=", "profile="])
		except Exception, e:
			show_error(unicode(e)+"\n"+usage)
			sys.exit()
		if not parameters[1]:
			show_error("SGF file missing\n"+usage)
			sys.exit()


		app=None
		batch=[]
		for filename in parameters[1]:
			move_selection,intervals,variation,komi,nogui,profile=parse_command_line(filename,parameters[0])
			if not profile:
				log("No profile indicated, the profile \""+existing_profiles[0]+"\" will be used")
				profile=existing_profiles[0]
			if profile not in existing_profiles:
				log("Unknown profile \""+profile+"\" for",bot["name"])
				log("The profile \""+profile+"\" is not defined in \"config.ini\"")
				log("The existing profiles are"," ".join(['"'+p+'"' for p in existing_profiles]))
				sys.exit()
			profile={p["profile"]:p for p in get_bot_profiles(bot["name"])}[profile]

			if isinstance(filename, str):
				filename = unicode(filename, 'utf-8')

			filename2=".".join(filename.split(".")[:-1])+".rsgf"
			if nogui:
				popup=bot["runanalysis"]("no-gui",[filename,filename2],move_selection,intervals,variation-1,komi,profile)
				popup.terminate_bot()
			else:
				if not app:
					app = Application()
				one_analysis=[bot["runanalysis"],[filename,filename2],move_selection,intervals,variation-1,komi,profile]
				batch.append(one_analysis)

		if not nogui:
			app.after(100,lambda: batch_analysis(app,batch))
			app.mainloop()

try:
	from playsound import playsound
	mp3=grp_config.get("General","StoneSound")
	if mp3:
		log("Reading",mp3)
		with open(mp3, mode='rb') as sound_file: #pre loading the sound file in memory
			fileContent = sound_file.read()

	def play_stone_sound():
		if mp3:
			threading.Thread(target=playsound, args=(mp3,)).start()

except Exception,e:
	log("Stone sound disabled:")
	log(e)
	play_stone_sound=lambda: None