Poker : analyse des mains et des résultats de tournois pour full tilt

Soyez le premier à donner votre avis sur cette source.

Snippet vu 10 844 fois - Téléchargée 215 fois

Contenu du snippet

Ce programme analyse les fichiers d'historiques des mains et des tournois de poker enregistrées par le logiciel de poker en ligne full tilt. Il prend en compte les résultats de tournois et sit&go à argent réel et fictif (table de cash game non prise en compte ainsi que les tournois de type matrix/ftp/satelites/com/event...). Une fois les fichiers d'historique analysés, les statistiques du joueur à tracker sont enregistrées et certains résultats sont présentés comme par exemple la valeur de sa caisse, le pourcentage de mains couchées préflop, de jolies courbes et statistiques en perspectives...
Remarque 1 : les mains doivent être enregistrées en anglais (paramétrable dans fulltilt).
Remarque 2 : Pour afficher les courbes, vous devrez installer numpy et matplotlib

Source / Exemple :


# -*- coding: cp1252 -*-
import Tkinter
import tkFileDialog
import os
import time
import datetime

#Penser a regarder le fichier non traites : by in, add on, knock out, temps de jeu
class PyTracker:
	def __init__(self, parent):
		"""Initialisation de l'IGU"""
		self.parent=parent
		self.loadOption()
		self.parent.title("Tracker Python pour Fulltilt")
		self.menuBar()
		container=Tkinter.Frame(self.parent)
		self.interface=Tkinter.Text(container)
		self.interface.insert('end','Bonjour et bienvenu\nPour tout renseignement tonny.rosca@gmail.com\n...')
		self.interface.insert('end',"Répertoire d'historique : "+str(self.pathIn)+"\n...")
		self.interface.insert('end',"Nombre de joueurs présents dans la base de donnée : "+str(len(self.joueurs.keys()))+"\n...")
		self.interface.insert('end',"Nombre de tournois présents dans la base de donnée : "+str(len(self.tournois['Listes']))+"\n...")
		self.interface.insert('end',"Nombre de mains présentes dans la base de donnée : "+str(len(self.mains['Listes']))+"\n...")
		self.interface.insert('end',"Nom du joueur : "+str(self.myLogginName)+"\n...")
		self.playerBaseStat()
		self.interface.yview('scroll',7,'units')
		self.interface.config(state='disable',width=150)
		self.interface.pack(side='left',expand='YES',fill='both')
		yscrollbar=Tkinter.Scrollbar(container)
		yscrollbar.pack(side='right',fill='y')
		container.pack(fill='both')
		yscrollbar.config(command=self.interface.yview)
		container.pack(fill='both',expand="YES")
		container2=Tkinter.Frame(self.parent)
		self.barreInterface=Tkinter.Text(container2)
		self.barreInterface.insert('end',str(len(self.tournois['Listes']))+" tournois, "+str(len(self.mains['Listes']))+" mains et "+str(len(self.joueurs.keys()))+" joueurs répertoriés dans la base de donnée.")
		self.barreInterface.config(state='disable',width=150,heigh=1,background='grey')
		self.barreInterface.pack(side='top',expand='YES',fill='both')
		container2.pack(fill='both')

	def menuBar(self):
		"""Initialisation de la barre de menu"""
		menu=Tkinter.Menu()
		fichier=Tkinter.Menu(tearoff=0)
		fichier.add_command(label='Remise à zéro',command=self.razAll)
		fichier.add_command(label='Quitter',command=self.parent.destroy)
		menu.add_cascade(label='Fichier',menu=fichier)
		outil=Tkinter.Menu(tearoff=0)
		outil.add_command(label='Tracker et analyser',command=self.tracker)
		outil.add_command(label='Afficher le nom des fichier ignorés lors du traitement',command=self.unknoFilePrint)
		menu.add_cascade(label='Outil',menu=outil)
		ArgentReel=Tkinter.Menu()
		ArgentReel.add_command(label="Analyse des tournois pour le joueur",command=self.tournoisReelStat)
		ArgentReel.add_command(label="Analyse des mains pour le joueur",command=self.mainsReelStat)
		ArgentReel.add_command(label="Résultats généraux pour le joueur",command=self.joueurReelStat)
		ArgentReel.add_command(label="Evolution de la caisse en fonction du temps",command=self.evolutionReelTournois)
		ArgentReel.add_command(label="Fréquence de la position finale sur 10",command=self.evolutionFrequencePositionReel)
		ArgentReel.add_command(label="Statistiques de tournois en fonction de l'entrée",command=self.entreeStatReelView)
		ArgentReel.add_command(label="Statistiques des mains en fonction de l'entrée",command=self.entreeMainsStatReelView)
		ArgentReel.add_command(label="Calculette de poche",command=self.calculette)
		menu.add_cascade(label='Argent réel',menu=ArgentReel)
		ArgentFictif=Tkinter.Menu()
		ArgentFictif.add_command(label="Annalyse des tournois pour le joueur",command=self.tournoisFictifStat)
		ArgentFictif.add_command(label="Annalyse des mains pour le joueur",command=self.mainsFictifStat)
		ArgentFictif.add_command(label="Résultats généraux pour le joueur",command=self.joueurFictifStat)
		ArgentFictif.add_command(label="Evolution de la caisse en fonction du temps",command=self.evolutionFictifTournois)
		ArgentFictif.add_command(label="Fréquence de la position finale sur 10",command=self.evolutionFrequencePositionFictif)
		ArgentFictif.add_command(label="Statistiques de tournois en fonction de l'entrée",command=self.entreeStatFictifView)
		ArgentFictif.add_command(label="Statistiques des mains en fonction de l'entrée",command=self.entreeMainsStatFictifView)
		ArgentFictif.add_command(label="Calculette de poche",command=self.calculette)
		menu.add_cascade(label='Argent fictif',menu=ArgentFictif)
		parameters=Tkinter.Menu(tearoff=0)
		parameters.add_command(label="Choix du répertoire d'historique",command=self.handHistoryPath)
		parameters.add_command(label="Choix du nom du joueur",command=self.myLoggin)
		menu.add_cascade(label='Parametres',menu=parameters)
		aide=Tkinter.Menu(tearoff=0)
		aide.add_command(label='A propos...',command=self.aboutVersion)
		aide.add_command(label='Aide',command=self.aboutAuthor)
		menu.add_cascade(label='?',menu=aide)
		self.parent.config(menu=menu)

	def aboutAuthor(self):
		"""Joindre l'auteur"""
		self.interface.config(state='normal')
		self.interface.insert('end',"En cours\n...")
		self.interface.yview('scroll',5,'units')
		self.interface.config(state='disable')
		self.yscrollbar.config(command=self.interface.yview)

	def aboutVersion(self):
		"""Version"""
		self.interface.config(state='normal')
		self.interface.insert('end',"pyTracker 2.5\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')
		self.yscrollbar.config(command=self.interface.yview)

	def handHistoryPath(self):
		"""Enregistrement des préférences du repertoire historique des mains"""
		self.pathIn=tkFileDialog.askdirectory(parent=self.parent,initialdir=self.pathIn,title="Choisissez le répertoire d'historique des mains")
		self.interface.config(state='normal')
		self.interface.insert('end',"Répertoire d'historique des mains : "+str(self.pathIn)+"\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')
		fichier=open('parameters_v2.py','w')
		fichier.write(self.pathIn+'\n')
		fichier.write(self.myLogginName+'\n')
		fichier.close()

	def myLoggin(self):
		"""Demande du nom du joueur"""
		self.windowPlayer=Tkinter.Toplevel()
		self.windowPlayer.title("Nom du joueur")
		containerP1=Tkinter.Frame(self.windowPlayer)
		containerP1.pack(fill='x')
		self.player=Tkinter.Entry(containerP1)
		self.player.pack(fill='x')
		self.player.insert('0',str(self.myLogginName))
		self.buttonP1=Tkinter.Button(containerP1,text='Valider',command=self.myLogginSave)
		self.buttonP1.pack(fill='x')
		self.buttonP2=Tkinter.Button(containerP1,text='Annuler',command=self.windowPlayer.destroy)
		self.buttonP2.pack(fill='x')

	def myLogginSave(self):
		"""Sauvegarde du nom de joueur par default"""
		self.myLogginName=self.player.get()
		self.windowPlayer.destroy()
		fichier=open('parameters_v2.py','w')
		fichier.write(self.pathIn+'\n')
		fichier.write(self.myLogginName+'\n')
		fichier.close()
		self.interface.config(state='normal')
		self.interface.insert('end',"Nom du joueur : "+str(self.myLogginName)+"\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')
		self.playerBaseStat()

	def loadOption(self):
		"""Chargement des options par default : loggin, repertoire d'historique, repertoires des donnees de sortie"""
		try:
			fichier=open("parameters_v2.py","r")
			self.pathIn=fichier.readline().split("\n")[0]
			self.myLogginName=fichier.readline().split("\n")[0]
			fichier.close()
			fichier=open("pyPlayerBase.py","r")
			for line in fichier.readlines():
				exec(line)
			fichier.close()
			self.joueurs=joueurs
			fichier=open("pyTournamentBase.py","r")
			for line in fichier.readlines():
				exec(line)
			fichier.close()
			self.tournois=tournois
			fichier=open("pyHandBase.py","r")
			for line in fichier.readlines():
				exec(line)
			fichier.close()
			self.mains=mains
		except:
			self.razAll()
		self.unknoFileList=[]

	def razAll(self):
		"""Remize a zero de la base de donnee des mains et des tournois ainsi que la liste des fichier dejà traites"""
		fichier=open("parameters_v2.py","w")
		fichier.write("Repertoire d'historique des mains\n")
		fichier.write("Nom du joueur\n")
		fichier.close()
		fichier=open("pyPlayerBase.py","w")
		fichier.write("joueurs={}\n")
		fichier.close()
		fichier=open("pyTournamentBase.py","w")
		fichier.write("tournois={}\n")
		fichier.write("tournois['Labels']=['Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h']\n")
		fichier.write("tournois['Listes']=[]\n")
		fichier.close()
		fichier=open("pyHandBase.py","w")
		fichier.write("mains={}\n")
		fichier.write("mains['Labels']=['Jetons','Tournois','Joueur','Date','Heure','Position','Tapis de depart','Position du button','Cartes en main','Pot final','Rake','Tableau','Statut','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu','Couché préflop','Nombre de joueurs']\n")
		fichier.write("mains['Listes']=[]\n")
		fichier.close()
		self.loadOption()
		try:
			self.interface.config(state='normal')
			self.interface.insert('end',"Remize à zéro de la base de donnée terminée\n...")
			self.interface.yview('scroll',1,'units')
			self.interface.config(state='disable')
			self.barreInterface.config(state='normal')
			self.barreInterface.delete(1.0,'end')
			self.barreInterface.insert('end',str(len(self.tournois['Listes']))+" Tournois, "+str(len(self.mains['Listes']))+" mains et "+str(self.myLogginName)+" joueurs répertoriés dans la base de donnée.")
			self.barreInterface.config(state='disable')
		except:
			pass

	def unknoFilePrint(self):
		"""Affichage du nom des fichiers ayant posé probleme lors du traitement"""
		self.interface.config(state='normal')
		self.interface.insert('end',"Liste des fichiers ignorés lors du traitement :\n...")
		for fichier in self.unknoFileList:
			self.interface.insert('end',"\t"+str(fichier)+"\n...")
		self.interface.yview('scroll',1+len(self.unknoFileList),'units')
		self.interface.config(state='disable')

	def playerBaseStat(self):
		"""Affiche le résumé de la quantité de la qualité des données présentes dans la base pour le joueur"""
		cptTournoisReel=0
		cptTournoisFictif=0
		cptMainsReel=0
		cptMainsFictif=0
		for tupple in self.tournois['Listes']:
			if tupple[4]==self.myLogginName:
				if tupple[15]=="Fictif":
					cptTournoisFictif+=1
				else:
					cptTournoisReel+=1
		for tupple in self.mains['Listes']:
			if tupple[2]==(str(self.myLogginName)):
				if tupple[0]=="Fictif":
					cptMainsFictif+=1
				else:
					cptMainsReel+=1
		try:
			self.joueurs[str(self.myLogginName)]['Resume donnees']={}
		except:
			self.joueurs[str(self.myLogginName)]={}
			self.joueurs[str(self.myLogginName)]['Resume donnees']={}
			self.joueurs[str(self.myLogginName)]['Fichiers']=[]
		self.joueurs[str(self.myLogginName)]['Resume donnees']['Tournois argent reel']=cptTournoisReel
		self.joueurs[str(self.myLogginName)]['Resume donnees']['Tournois argent fictif']=cptTournoisFictif
		self.joueurs[str(self.myLogginName)]['Resume donnees']['Mains argent reel']=cptMainsReel
		self.joueurs[str(self.myLogginName)]['Resume donnees']['Mains argent fictif']=cptMainsFictif
		self.saveBase()
		self.interface.config(state='normal')
		self.interface.insert('end',"Résultats de l'analyse pour le joueur : "+str(self.myLogginName)+"\n...")
		self.interface.insert('end',"\tRésultats d'analyse de la base de donnée des tournois\n...")
		self.interface.insert('end',"\t\tNombre de tournois présents dans la base de donnée pour le joueur : "+str(cptTournoisReel+cptTournoisFictif)+"\n...")
		self.interface.insert('end',"\t\tNombre de tournois à argent réel présents dans la base de donnée pour le joueur : "+str(cptTournoisReel)+"\n...")
		self.interface.insert('end',"\t\tNombre de tournois à argent fictif présents dans la base de donnée pour le joueur : "+str(cptTournoisFictif)+"\n...")
		self.interface.insert('end',"\tRésultats d'analyse de la base de donnée des mains\n...")
		self.interface.insert('end',"\t\tNombre de mains présentes dans la base de donnée pour le joueur : "+str(cptMainsReel+cptMainsFictif)+"\n...")
		self.interface.insert('end',"\t\tNombre de mains à argent réel présents dans la base de donnée pour le joueur : "+str(cptMainsReel)+"\n...")
		self.interface.insert('end',"\t\tNombre de mains à argent fictif présents dans la base de donnée pour le joueur : "+str(cptMainsFictif)+"\n...")
		self.interface.yview('scroll',10,'units')
		self.interface.config(state='disable')

	def saveBase(self):
		"""Mise à jour des bases de donnees"""
		fichier=open("pyTournamentBase.py","w")
		fichier.write("tournois={}\n")
		fichier.write("tournois['Labels']=[('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h')]\n")
		fichier.write("tournois['Listes']=[]\n")
		for tournois in self.tournois['Listes']:
			fichier.write("tournois['Listes']+=["+str(tournois)+"]\n")
		fichier.close()
		fichier=open("pyHandBase.py","w")
		fichier.write("mains={}\n")
		fichier.write("mains['Labels']=['Jetons','Tournois','Joueur','Date','Heure','Position','Tapis de depart','Position du button','Cartes en main','Pot final','Rake','Tableau','Statut','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu','Couché préflop','Nombre de joueurs']\n")
		fichier.write("mains['Listes']=[]\n")
		for mains in self.mains['Listes']:
			fichier.write("mains['Listes']+=["+str(mains)+"]\n")
		fichier.close()
		fichier=open("pyPlayerBase.py","w")
		fichier.write("joueurs={}\n")
		for keys in self.joueurs.keys():
			fichier.write("joueurs['"+str(keys)+"']={}\n")
			for key in self.joueurs[str(keys)]:
				fichier.write("joueurs['"+str(keys)+"']['"+str(key)+"']="+str(self.joueurs[keys][key])+"\n")
		fichier.close()

	def tracker(self):
		"""Analyse les fichiers présents dans le repertoire parent et appelle les fonctions de traitement adaptées en fonction du type de fichier"""
		self.loadOption()
		self.playerBaseStat()
		examFile=0
		unknoFile=0
		alreadyTreatedFile=0
		analysedFile=0
		noPlayerFile=0
		tableFile=0
		totalFile=0
		self.interface.config(state='normal')
		self.interface.insert('end',"Recherche des fichiers à traiter\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')
		for self.root, dirs, self.fileIn in os.walk(self.pathIn):
			self.interface.config(state='normal')
			self.interface.insert('end',"Nombre de fichiers présents dans le répertoire : "+str(len(self.fileIn))+"\n...")
			self.interface.yview('scroll',1,'units')
			self.interface.config(state='disable')
			for self.fileStack in range(0,len(self.fileIn)):
				totalFile+=1
				self.barreInterface.config(state='normal')
				self.barreInterface.delete(1.0,'end')
				self.barreInterface.insert('end',str(len(self.tournois['Listes']))+" tournois et "+str(len(self.mains['Listes']))+" mains répertoriés dans la base de donnée. "+str(self.fileStack+1)+" fichier traités sur "+str(len(self.fileIn)))
				self.barreInterface.config(state='disable')
				self.parent.update()
				self.interface.config(state='normal')
				self.interface.insert('end',"Traitement du fichier "+str(self.fileIn[self.fileStack])+"\n...")
				self.interface.yview('scroll',1,'units')
				self.interface.config(state='disable')
				if not self.joueurs[self.myLogginName]['Fichiers'].count(str(self.fileIn[self.fileStack])+'\n'):#teste si le fichier a deja ete traite
					self.interface.config(state='normal')
					self.interface.insert('end',"Nouveau fichier détecté. Traitement en cours\n...")
					self.interface.yview('scroll',1,'units')
					self.interface.config(state='disable')
					fichier=open(str(self.root)+'/'+self.fileIn[self.fileStack],"r")
					if not fichier.read().count(self.myLogginName):
						self.interface.config(state='normal')
						self.interface.insert('end',"Le joueur n'est pas présent dans le fichier\n...")
						self.interface.yview('scroll',1,'units')
						self.interface.config(state='disable')
						fichier.close()
						noPlayerFile+=1
					elif not (self.fileIn[self.fileStack].count("Sit & Go") or self.fileIn[self.fileStack].count("Tournament") or self.fileIn[self.fileStack].count("Sit&Go") or self.fileIn[self.fileStack].count("Freeroll") or self.fileIn[self.fileStack].count("Knockout") or self.fileIn[self.fileStack].count("Rebuy") or self.fileIn[self.fileStack].count("Early Double")):
						self.interface.config(state='normal')
						self.interface.insert('end',"Le fichier est de type inconnu.\n...")
						self.interface.yview('scroll',1,'units')
						self.interface.config(state='disable')
						fichier.close()
						unknoFile+=1
						self.unknoFileList=self.unknoFileList+[str(self.fileIn[self.fileStack])]####
					else:
						examFile+=1
						self.interface.config(state='normal')
						self.interface.insert('end',"Le joueur est présent dans le fichier. Traitement du fichier en cours\n...")
						self.interface.yview('scroll',1,'units')
						self.interface.config(state='disable')
						fichier.close()
						#teste si le fichier est un resume de tournois ou pas
						if self.fileIn[self.fileStack].count("Summary")==1: #fichier "resume du tournois trouve"
							self.interface.config(state='normal')
							self.interface.insert('end',"Fichier résumé de tournois détecté. Traitement en cours\n...")
							self.interface.yview('scroll',1,'units')
							self.interface.config(state='disable')
							self.trackerTournois()
						else:
							self.interface.config(state='normal')
							self.interface.insert('end',"Fichier historique classique détecté. Traitement en cours\n...")
							self.interface.yview('scroll',1,'units')
							self.interface.config(state='disable')
							self.trackerMains()
						analysedFile+=1
						self.joueurs[str(self.myLogginName)]['Fichiers']=self.joueurs[str(self.myLogginName)]['Fichiers']+[str(self.fileIn[self.fileStack])+"\n"]
				else:
					self.interface.config(state='normal')
					self.interface.insert('end',"Le fichier à déjà été analysé.\n...")
					self.interface.yview('scroll',1,'units')
					self.interface.config(state='disable')
					alreadyTreatedFile+=1
				self.interface.config(state='normal')
				self.interface.insert('end',"Traitement du fichier terminé.\n...")
				self.interface.yview('scroll',1,'units')
				self.interface.config(state='disable')
		self.playerBaseStat()
		self.interface.config(state='normal')
		self.interface.insert('end',"Traitement terminé\n...")
		self.interface.insert('end',str(analysedFile)+" fichier(s) traité(s) sur "+str(totalFile)+" \n...")
		self.interface.insert('end',str(alreadyTreatedFile)+" fichier(s) déjà présent(s) dans la base de donnée\n...")
		self.interface.insert('end',str(unknoFile)+" nouveau(x) fichier(s) de type inconu\n...")
		self.interface.insert('end',str(noPlayerFile)+" fichier(s) ou le joueur n'est pas présent\n...")
		self.interface.insert('end',"Analyse des résultats généraux de tournois de "+str(self.myLogginName)+"\n...")
		self.tournoisStatAnalyser()
		self.interface.insert('end',"Analyse des résultats généraux de tournois de "+str(self.myLogginName)+" terminée\n...")
		self.interface.insert('end',"Analyse des résultats généraux des mains de "+str(self.myLogginName)+"\n...")
		self.mainsStatAnalyser()
		self.interface.insert('end',"Analyse des résultats généraux des mains de "+str(self.myLogginName)+" terminée\n...")
		self.interface.yview('scroll',9,'units')
		self.interface.config(state='disable')
		self.entreeStatFictif()
		self.entreeStatReel()
		self.entreeMainsStatReel()
		self.entreeMainsStatFictif()
		self.saveBase()

	def trackerTournois(self):
		"""Traitement des fichiers de type résumés de tournois"""
		fichier=open(str(self.root)+"/"+str(self.fileIn[self.fileStack]),"r")
		lines=fichier.readlines()
		fichier.close()
		#if not str(self.fileIn[self.fileStack]).count(""):
		nom=str(self.fileIn[self.fileStack]).split("(")[1].split(")")[0]
		#else:
		#	nom=str(self.fileIn[self.fileStack]).split("(")[2].split(")")[0]
		joueur=str(self.myLogginName)
		tempsModification=time.gmtime(os.stat(str(self.root)+"/"+str(self.fileIn[self.fileStack])).st_mtime)
		tempsModificationHeure=time.ctime(os.stat(str(self.root)+"/"+str(self.fileIn[self.fileStack])).st_mtime).split(" ")[3].split(":")[0]+":"+time.ctime(os.stat(str(self.root)+"/"+str(self.fileIn[self.fileStack])).st_mtime).split(" ")[3].split(":")[1]
		anneeF=str(tempsModification[0])
		moiF=int(tempsModification[1])
		knockOut="-"
		knockOutBounty="-"
		addOnBounty="-"
		rebuyBounty="-"
		addOn="-"
		rebuy="-"
		if moiF<=9:
			moiF="0"+str(moiF)
		jourF=int(tempsModification[2])
		if jourF<=9:
			jourF="0"+str(jourF)
		dateFin=str(anneeF)+"/"+str(moiF)+"/"+str(jourF)
		if int(tempsModificationHeure.split(":")[0])==0:
			heureF=24
			minuteF=int(tempsModificationHeure.split(":")[1])
			if minuteF<=9:
				minuteF="0"+str(minuteF)
		else:
			heureF=int(tempsModificationHeure.split(":")[0])
			if heureF<=9:
				heureF="0"+str(heureF)
			minuteF=int(tempsModificationHeure.split(":")[1])
			if minuteF<=9:
				minuteF="0"+str(minuteF)
		heureFin=str(heureF)+":"+str(minuteF)
		for line in lines:
			if line.count("Buy-In:"):
				if line.count("Jetons d'argent fictif"):
					try:
						jetons='Fictif'
						entree="".join(line.split(":")[1].split("\n")[0].split("Jetons d'argent fictif")[0].split(",")[:])#fictif
						rake="".join(line.split("+")[1].split("Jetons d'argent fictif")[0].split(",")[:])#fictif
					except:
						jetons='Fictif'
						entree=line.split(":")[1].split("\n")[0].split("Jetons d'argent fictif")[0]#fictif
						rake=line.split("+")[1].split("Jetons d'argent fictif")[0]#fictif
				elif line.count("FTP"):
					jetons='Réel'
					entree="".join(line.split(":")[1].split("+")[0].split("FTP")[:])#$
					rake="".join(line.split("+")[1].split("\n")[0].split("FTP")[:])
				else:
					jetons='Réel'
					entree="".join(line.split(":")[1].split("+")[0].split("$")[:])#$
					rake="".join(line.split("+")[1].split("\n")[0].split("$")[:])
			if line.count("Knockout Bounty:") and not(line.count(str(self.myLogginName))):
				if jetons=="Fictif":
					knockOutBounty=float(line.split(":")[1].split("Jetons d'argent fictif")[0])
				else:
					knockOutBounty=float(line.split("$")[1])
			if line.count("Rebuy:") and not(line.count(str(self.myLogginName))):
				if jetons=="Fictif":
					rebuyBounty=float(line.split(":")[1].split("Jetons d'argent fictif")[0])
				else:
					rebuyBounty=float(line.split("$")[1])
			if line.count("Add-On:") and not(line.count(str(self.myLogginName))):
				if jetons=="Fictif":
					addOnBounty=float(line.split(":")[1].split("Jetons d'argent fictif")[0])
				else:
					addOnBounty=float(line.split("$")[1])
			if line.count("Entries"):
				nombreJoueurs=line.split(" ")[0]
			if line.count("Tournament started:"):
				#6h de decalage : teste si on change de jour:
				heure=line.split("Tournament started: ")[1].split(" ")[1]
				if float(heure.split(":")[0])>=19:
					heureDebut=str(int(heure.split(":")[0])-24+6)+":"+str(int(heure.split(":")[1]))
					date=line.split("Tournament started: ")[1].split(" ")[0]
					dateDebut=str(int(date.split("/")[0]))+"/"+str(int(date.split("/")[1]))+"/"+str(int(date.split("/")[2])+1)
				else:
					heureDebut=str(int(heure.split(":")[0])+6)+":"+str(int(heure.split(":")[1]))
					dateDebut=line.split("Tournament started: ")[1].split(" ")[0]
				if float(dateDebut.split("/")[0])==float(dateFin.split("/")[0]) and float(dateDebut.split("/")[1])==float(dateFin.split("/")[1]) and float(dateDebut.split("/")[2])==float(dateFin.split("/")[2]) :
					tempsDebutMinute=float(heureDebut.split(":")[0])*60+float(heureDebut.split(":")[1])
					tempsFinMinute=float(heureFin.split(":")[0])*60+float(heureFin.split(":")[1])
					deltaT=tempsFinMinute-tempsDebutMinute
					deltaTHeure=int(deltaT/60)
					deltaTMinute=int((float(deltaT/60)-int(deltaT/60))*60)
					tempsJeu=str(int(deltaTHeure))+":"+str(int(deltaTMinute))
				else:
					tempsDebutMinute=float(heureDebut.split(":")[0])*60+float(heureDebut.split(":")[1])
					tempsFinMinute=float(heureFin.split(":")[0])*60+float(heureFin.split(":")[1])
					deltaT=24*60-tempsDebutMinute+tempsFinMinute
					deltaTHeure=int(deltaT/60)
					deltaTMinute=int((float(deltaT/60)-int(deltaT/60))*60)
					tempsJeu=str(deltaTHeure)+":"+str(deltaTMinute)
 			if line.count(self.myLogginName) and (line.count("Knockout Bounty")):
				knockOut=float(knockOutBounty)*float(line.split(str(self.myLogginName)+" received ")[1].split("Knockout Bounty Award")[0])
 			if line.count(self.myLogginName) and (line.count("Rebuy")):
				rebuy=rebuyBounty*float(line.split(str(self.myLogginName)+" performed ")[1].split("Rebuy")[0])
 			if line.count(self.myLogginName) and (line.count("Add-On")):
				addOn=addOnBounty*float(line.split(str(self.myLogginName)+" performed ")[1].split("Add-On")[0])
 			if line.count(self.myLogginName) and (not line.count("Knockout Bounty")) and (not line.count("Add-On")) and (not line.count("Rebuy")):
				if line.count("Still Playing"):
					positionFinale="-"
					positionFinale10="-"
					sortie="-"
					gains="-"
					ROI="-"
					dolardH="-"
				else:
					positionFinale=line.split("\n")[0].split(":")[0]
					positionFinale10=int(float(positionFinale)/float(nombreJoueurs)*10)
					if positionFinale10==0:
						positionFinale10=1
					if line.count("Jeton"):
						sortie=float("".join(line.split(self.myLogginName)[1].split("\n")[0].split("Jetons")[0].split(",")[:]))
						if knockOut=="-":
							gains=float(sortie)-float(entree)-float(rake)
						else:
							gains=float(sortie)-float(entree)-float(rake)+float(knockOut)
						ROI=int(100*(float(gains)/(float(entree)+float(rake))))
						if not float((float(deltaT)/60))==0:
							dolardH=int(float(gains)/float((float(deltaT)/60)))
						else:
							dolardH=int(float(gains)/float((float(1)/60)))
					else:
						if line.count("$"):
							try:
								if line.count("Satellite Token"):
									sortie=float("".join("".join("".join(line.split(self.myLogginName)[1].split("\n")[0].split(",")[:]).split("$")[:])).split("Satellite Token")[0])#$
								else:
									sortie=float(line.split(self.myLogginName)[1].split("\n")[0].split(".")[0]+","+line.split(self.myLogginName)[1].split("\n")[0].split(".")[1])#$
								if knockOut=="-":
									gains=float(sortie)-float(entree)-float(rake)
								else:
									gains=float(sortie)-float(entree)-float(rake)+float(knockOut)
								ROI=int(100*(float(gains)/(float(entree)+float(rake))))
								if not float((float(deltaT)/60))==0:
									dolardH=int(float(gains)/float((float(deltaT)/60)))
								else:
									dolardH=int(float(gains)/float((float(1)/60)))
							except:
								if line.count("Satellite Token"):
									sortie=float("".join("".join("".join(line.split(self.myLogginName)[1].split("\n")[0].split(",")[:]).split("$")[:])).split("Satellite Token")[0])#$
								else:
									sortie=float("".join("".join(line.split(self.myLogginName)[1].split("\n")[0].split(",")[:]).split("$")[:]))#$
								if knockOut=="-":
									gains=float(sortie)-float(entree)-float(rake)
								else:
									gains=float(sortie)+float(knockOut)-float(entree)-float(rake)
								ROI=int(100*(float(gains)/(float(entree)+float(rake))))
								if not float((float(deltaT)/60))==0:
									dolardH=int(float(gains)/float((float(deltaT)/60)))
								else:
									dolardH=int(float(gains)/float((float(1)/60)))
						else:
							sortie=0
							if knockOut=="-":
								gains=float(sortie)-float(entree)-float(rake)
							else:
								gains=float(sortie)+float(knockOut)-float(entree)-float(rake)
							if float(entree)==0:
								ROI="-"
								if not float((float(deltaT)/60))==0:
									dolardH=int(float(gains)/float((float(deltaT)/60)))
								else:
									dolardH=int(float(gains)/float((float(1)/60)))
							else:
								ROI=int(100*(float(gains)/(float(entree)+float(rake))))
								if not float((float(deltaT)/60))==0:
									dolardH=int(float(gains)/float((float(deltaT)/60)))
								else:
									dolardH=int(float(gains)/float((float(1)/60)))
				break
		#('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h','Knock out','Knock out bounty','Temps de jeu','Reby','Add-on')]
		self.tournois['Listes']+=[(nombreJoueurs,ROI,heureDebut,entree,joueur,heureFin,dateDebut,rake,sortie,gains,positionFinale,tempsJeu,nom,dateFin,positionFinale10,jetons,dolardH,knockOut,knockOutBounty,rebuy,addOn)]
		#self.saveBase()
		self.interface.config(state='normal')
		self.interface.insert('end',"Traitement du fichier terminé avec succes\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')

	def tournoisFictifStat(self):
		""""Affichage des donnees résumé des resultats de tournois en argent fictif"""
		self.affichageTournoisArgent="Fictif"
		self.tournoisStat()

	def tournoisReelStat(self):
		""""Affichage des donnees résumé des resultats de tournois en argent fictif"""
		self.affichageTournoisArgent="Réel"
		self.tournoisStat()

	def tournoisStat(self):
		""""Affichage des donnees résumé des resultats de tournois en argent fictif"""
		self.windowsTournoisFictif=Tkinter.Toplevel()
		self.tournois['Listes'].sort(lambda a,b:cmp(a[5],b[5]))
		self.tournois['Listes'].sort(lambda a,b:cmp(a[13],b[13]))
		if self.affichageTournoisArgent=="Réel":
			self.windowsTournoisFictif.title("Résultats de tournois en argent réel de "+str(self.myLogginName))
		else:
			self.windowsTournoisFictif.title("Résultats de tournois en argent fictif de "+str(self.myLogginName))
		self.iguTournois={}
		self.iguTournois['En tete']={}
		self.iguTournois['En tete']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Donnees']={}
		self.iguTournois['Donnees']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Min']={}
		self.iguTournois['Min']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Max']={}
		self.iguTournois['Max']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Moy']={}
		self.iguTournois['Moy']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Tot']={}
		self.iguTournois['Tot']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Barre interface']={}
		self.iguTournois['Barre interface']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.iguTournois['Deffilement']={}
		self.iguTournois['Deffilement']['Container']=Tkinter.Frame(self.windowsTournoisFictif)
		self.keysTournois=['Date de debut','Heure de debut','Date de fin','Heure de fin','Temps de jeu','Entree','Rake','Nombre de joueurs','Position finale','Position finale sur 10','Sortie','Knock Out','Gains','ROI','$/h']
		keysTournoisStack=[6,2,13,5,11,3,7,0,10,14,8,17,9,1,16]#('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h','Knock Out','Knock Out Bounty')]]
		keysTournoisWidth=[10,5,10,5,5,10,10,5,5,5,10,10,10,10,10]
		largeurTot=0
		for stack in range(0,len(self.keysTournois)):
			self.iguTournois['En tete'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['En tete']['Container'])
			self.iguTournois['En tete'][self.keysTournois[stack]].insert('end',str(self.keysTournois[stack]))
			self.iguTournois['En tete'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=5,state='disable',background='grey')
			self.iguTournois['En tete'][self.keysTournois[stack]].pack(side='left')
			self.iguTournois['Donnees'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['Donnees']['Container'])
			for tupple in self.tournois['Listes']:
				if tupple[4]==str(self.myLogginName) and tupple[15]==str(self.affichageTournoisArgent):
					self.iguTournois['Donnees'][self.keysTournois[stack]].insert('end',str(tupple[keysTournoisStack[stack]])+"\n")
			self.iguTournois['Donnees'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=30,state='disable')
			self.iguTournois['Donnees'][self.keysTournois[stack]].pack(side='left')
			self.iguTournois['Min'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['Min']['Container'])
			self.iguTournois['Min'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=1)
			self.iguTournois['Min'][self.keysTournois[stack]].pack(side='left')
			self.iguTournois['Max'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['Max']['Container'])
			self.iguTournois['Max'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=1)
			self.iguTournois['Max'][self.keysTournois[stack]].pack(side='left')
			self.iguTournois['Moy'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['Moy']['Container'])
			self.iguTournois['Moy'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=1)
			self.iguTournois['Moy'][self.keysTournois[stack]].pack(side='left')
			self.iguTournois['Tot'][self.keysTournois[stack]]=Tkinter.Text(self.iguTournois['Tot']['Container'])
			self.iguTournois['Tot'][self.keysTournois[stack]].config(width=keysTournoisWidth[stack],height=1)
			self.iguTournois['Tot'][self.keysTournois[stack]].pack(side='left')
			largeurTot=largeurTot+keysTournoisWidth[stack]
		self.iguTournois['En tete']['Container'].grid(row=0,column=0)
		self.iguTournois['Donnees']['Container'].grid(row=1,column=0)
		self.iguTournois['Min']['Container'].grid(row=2,column=0)
		self.iguTournois['Max']['Container'].grid(row=3,column=0)
		self.iguTournois['Moy']['Container'].grid(row=4,column=0)
		self.iguTournois['Tot']['Container'].grid(row=5,column=0)
		self.iguTournois['Deffilement']['Haut']=Tkinter.Button(self.iguTournois['Deffilement']['Container'],text="Up",command=self.viewTournoisUp)
		self.iguTournois['Deffilement']['Haut'].pack()
		self.iguTournois['Deffilement']['Bas']=Tkinter.Button(self.iguTournois['Deffilement']['Container'],text="Down",command=self.viewTournoisDown)
		self.iguTournois['Deffilement']['Bas'].pack()
		self.iguTournois['Deffilement']['Container'].grid(rowspan=6,column=1,row=0)
		self.iguTournois['Barre interface']['Texte']=Tkinter.Text(self.iguTournois['Barre interface']['Container'])
		if self.affichageTournoisArgent=="Fictif":
			self.iguTournois['Barre interface']['Texte'].insert('end',str(self.joueurs[str(self.myLogginName)]['Resume donnees']['Tournois argent fictif'])+" tournois analysées pour le joueur "+str(self.myLogginName))
		else:
			self.iguTournois['Barre interface']['Texte'].insert('end',str(self.joueurs[str(self.myLogginName)]['Resume donnees']['Tournois argent reel'])+" tournois analysées pour le joueur "+str(self.myLogginName))
		self.iguTournois['Barre interface']['Texte'].config(heigh=1,background='grey',width=largeurTot+12,state='disable')
		self.iguTournois['Barre interface']['Texte'].pack()
		self.iguTournois['Barre interface']['Container'].grid(row=6,columnspan=2)
		keysStatTournois=['Temps de jeu','Entree','Rake','Nombre de joueurs','Position finale','Position finale sur 10','Sortie','Knock Out','Gains','ROI','$/h']
		self.iguTournois['Min']['Heure de fin'].insert('end',"Minimum\n")
		self.iguTournois['Max']['Heure de fin'].insert('end',"Maximum\n")
		self.iguTournois['Moy']['Heure de fin'].insert('end',"Moyen\n")
		self.iguTournois['Tot']['Heure de fin'].insert('end',"Total\n")
		self.iguTournois['Min']['Heure de fin'].config(state='disable',foreground='red')
		self.iguTournois['Max']['Heure de fin'].config(state='disable',foreground='red')
		self.iguTournois['Moy']['Heure de fin'].config(state='disable',foreground='red')
		self.iguTournois['Tot']['Heure de fin'].config(state='disable',foreground='red')
		stack=0
		for key in keysStatTournois:
			#print str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Min'][0])
			self.iguTournois['Min'][key].insert('end',str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Min'][stack]))
			self.iguTournois['Min'][key].config(state='disable',foreground='blue')
			self.iguTournois['Max'][key].insert('end',str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Max'][stack]))
			self.iguTournois['Max'][key].config(state='disable',foreground='blue')
			self.iguTournois['Moy'][key].insert('end',str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Moy'][stack]))
			self.iguTournois['Moy'][key].config(state='disable',foreground='blue')
			self.iguTournois['Tot'][key].insert('end',str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Tot'][stack]))
			self.iguTournois['Tot'][key].config(state='disable',foreground='blue')
			stack+=1
		for key in self.iguTournois['Min'].keys():
			try:
				self.iguTournois['Tot'][key].config(state='disable')
				self.iguTournois['Moy'][key].config(state='disable')
				self.iguTournois['Max'][key].config(state='disable')
				self.iguTournois['Min'][key].config(state='disable')
			except:
				pass

	def viewTournoisUp(self):
		"""Monte dans le tableau des mains"""
		for key in self.keysTournois:
			self.iguTournois['Donnees'][key].yview('scroll',-10,'units')

	def viewTournoisDown(self):
		"""Descand dans le tableau des mains"""
		for key in self.keysTournois:
			self.iguTournois['Donnees'][key].yview('scroll',10,'units')

	def tournoisStatAnalyser(self):
		"""Analyse des résultats de tournois : min/max/moy/tot"""
		#self.keysTournois=['Date de debut','Heure de debut','Date de fin','Heure de fin','Temps de jeu','Entree','Rake','Nombre de joueurs','Position finale','Position finale sur 10','Sortie','Gains','ROI','$/h','Knock Out','Knock Out Bounty']
		keysTournoisStack=[11,3,7,0,10,14,8,17,9,1,16]#('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h','Knock Out','Knock Out Bounty')]]
		self.joueurs[str(self.myLogginName)]['Statistique tournois']={}
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Label']=('Temps de jeu','Entree','Rake','Nombre de joueurs','Position finale sur 10','Sortie','Gains','ROI','$/h')
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']={}
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Moy']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot']=[0,0,0,0,0,0,0,0,0,0,0]
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']={}
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Moy']=['-','-','-','-','-','-','-','-','-','-','-','-']
		self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot']=[0,0,0,0,0,0,0,0,0,0,0]
		cptReel=0
		cptFictif=0
		for tupple in self.tournois['Listes']:
			if tupple[15]=="Fictif" and tupple[4]==str(self.myLogginName):
				stackF=0
				for stat in self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot']:
					if stackF==0:
						mark=keysTournoisStack[stackF]
						if not tupple[mark]=="-":
							cptFictif+=1
							tempsJeuMinute=int(tupple[mark].split(":")[0])*60+int(tupple[mark].split(":")[1])
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF])>=float(tempsJeuMinute):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=float(tempsJeuMinute)
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=float(tempsJeuMinute)
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF])<=float(tempsJeuMinute):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=float(tempsJeuMinute)
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=float(tempsJeuMinute)
							self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'][stackF]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'][stackF])+float(tempsJeuMinute)
						stackF+=1
					else:
						mark=keysTournoisStack[stackF]
						if not tupple[mark]=="-":
							cptFictif+=1
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF])>=float(tupple[mark]):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=float(tupple[mark])
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Min'][stackF]=float(tupple[mark])
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF])<=float(tupple[mark]):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=float(tupple[mark])
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Max'][stackF]=float(tupple[mark])
							self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'][stackF]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'][stackF])+float(tupple[mark])
						stackF+=1
			if tupple[15]=="Réel" and tupple[4]==str(self.myLogginName):
				stack=0
				for stat in self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot']:
					if stack==0:
						mark=keysTournoisStack[stack]
						if not tupple[mark]=="-":
							cptReel+=1
							tempsJeuMinuteR=int(tupple[mark].split(":")[0])*60+int(tupple[mark].split(":")[1])
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack])>=float(tempsJeuMinuteR):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=float(tempsJeuMinuteR)
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=float(tempsJeuMinuteR)
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack])<=float(tempsJeuMinuteR):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=float(tempsJeuMinuteR)
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=float(tempsJeuMinuteR)
							self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'][stack])+float(tempsJeuMinuteR)
						stack+=1
					else:
						mark=keysTournoisStack[stack]
						if not tupple[mark]=="-":
							cptReel+=1
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack])>=float(tupple[mark]):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=float(tupple[mark])
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Min'][stack]=float(tupple[mark])
							if not self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=="-":
								if float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack])<=float(tupple[mark]):
									self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=float(tupple[mark])
							else:
								self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Max'][stack]=float(tupple[mark])
							self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'][stack])+float(tupple[mark])
						stack+=1
		if cptReel:
			for stack in range(0,len(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'])):
				self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Moy'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot'][stack])/float(cptReel)*float(len(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Réel']['Tot']))
		if cptFictif:
			for stack in range(0,len(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'])):
				self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Moy'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot'][stack])/float(cptFictif)*float(len(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent Fictif']['Tot']))

	def trackerMains(self):
		"""Traque des mains sur les tournois et s&g"""
		fichier=open(str(self.root)+"/"+str(self.fileIn[self.fileStack]),"r")
		lines=fichier.readlines()
		fichier.close()
		stack=0;
		while stack<len(lines):#On parcours toutes les lignes
			if lines[stack].count("Full Tilt Poker Game"):#On detecte une nouvelle main
				try:
					if lines[stack].count("Play Money") or lines[stack].count("Play Chip") :
						MJetons='Fictif'
					else:
						MJetons='Réel'
					MTournois=lines[stack].split("(")[1].split(")")[0]
					MJoueur=str(self.myLogginName)
					MDate=lines[stack].split("-")[4].split("\n")[0].split("/")[2]+"/"+lines[stack].split("-")[4].split("\n")[0].split("/")[1]+"/"+lines[stack].split("-")[4].split("\n")[0].split("/")[0]
					MHeure=lines[stack].split("-")[3].split("ET")[0]
					MPosition="-"
					MTapis="-"
					MPositionButton="-"
					MCartes="-"
					MPot="-"
					MRake="-"
					MTableau="-"
					MStatut="-"
					MCoucheFlop="-"
					MCoucheTurn="-"
					MCoucheRiver="-"
					MGagneSansMontrer="-"
					MGagneEnMontrant="-"
					MPerd="-"
					MCouchePreflop="-"
					MNombreJoueurs=0
					stack+=1
					while lines[stack].count("Seat"):
						MNombreJoueurs+=1
						if lines[stack].count(self.myLogginName):
							MPosition=lines[stack].split(" ")[1].split(":")[0]
							try:
								MTapis="".join(lines[stack].split("(")[1].split(")")[0].split(",")[:])
							except:
								MTapis=lines[stack].split("(")[1].split(")")[0]
						stack+=1
					while not lines[stack].count("button"):
						stack+=1
					try:
						MPositionButton=lines[stack].split("Seat")[1].split(":")[0]
					except:
						MPositionButton=lines[stack].split("#")[1].split("\n")[0]
					stack+=2
					if lines[stack].count("Dealt to "+str(self.myLogginName)):
						MCartes=lines[stack].split("[")[1].split("]")[0]
					else:
						MCartes="-"
					while not lines[stack].count("SUMMARY"):
						stack+=1
					stack+=1
					MPot="".join(lines[stack].split("Total pot ")[1].split("|")[0].split(",")[:])
					MRake="".join(lines[stack].split("Rake ")[1].split("\n")[0].split(",")[:])
					stack+=1
					if lines[stack].count("Board"):
						MTableau=lines[stack].split("[")[1].split("]")[0]
						stack+=1
					else:
						MTableau="-"
					while lines[stack].count("Seat"):
						if lines[stack].count(self.myLogginName):
							if lines[stack].split(self.myLogginName)[1].split("\n")[0].count("folded on the Flop"):
								MCoucheFlop=1
								MCoucheTurn=0
								MCoucheRiver=0
								MGagneSansMontrer=0
								MGagneEnMontrant=0
								MPerd=0
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("folded on the Turn"):
								MCoucheFlop=0
								MCoucheTurn=1
								MCoucheRiver=0
								MGagneSansMontrer=0
								MGagneEnMontrant=0
								MPerd=0
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("folded on the River"):
								MCoucheFlop=0
								MCoucheTurn=0
								MCoucheRiver=1
								MGagneSansMontrer=0
								MGagneEnMontrant=0
								MPerd=0
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("collected") or lines[stack].split(self.myLogginName)[1].split("\n")[0].count("mucked") :
								MCoucheFlop=0
								MCoucheTurn=0
								MCoucheRiver=0
								MGagneSansMontrer=1
								MGagneEnMontrant=0
								MPerd=0
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("show") and lines[stack].split(self.myLogginName)[1].split("\n")[0].count("won"):
								MCoucheFlop=0
								MCoucheTurn=0
								MCoucheRiver=0
								MGagneSansMontrer=0
								MGagneEnMontrant=1
								MPerd=0
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("show") and lines[stack].split(self.myLogginName)[1].split("\n")[0].count("lost"):
								MCoucheFlop=0
								MCoucheTurn=0
								MCoucheRiver=0
								MGagneSansMontrer=0
								MGagneEnMontrant=0
								MPerd=1
								MCouchePreflop=0
							elif lines[stack].split(self.myLogginName)[1].split("\n")[0].count("folded before the Flop") or lines[stack].split(self.myLogginName)[1].split("\n")[0].count("didn't bet") :
								MCoucheFlop=0
								MCoucheTurn=0
								MCoucheRiver=0
								MGagneSansMontrer=0
								MGagneEnMontrant=0
								MPerd=0
								MCouchePreflop=1
							else:
								MCoucheFlop="-"
								MCoucheTurn="-"
								MCoucheRiver="-"
								MGagneSansMontrer="-"
								MGagneEnMontrant="-"
								MPerd="-"
								MCouchePreflop="-"
							MStatut=lines[stack].split(self.myLogginName)[1].split("\n")[0]
						stack+=1
					self.mains['Listes']+=[(MJetons,MTournois,MJoueur,MDate,MHeure,MPosition,MTapis,MPositionButton,MCartes,MPot,MRake,MTableau,MStatut,MCoucheFlop,MCoucheTurn,MCoucheRiver,MGagneSansMontrer,MGagneEnMontrant,MPerd,MCouchePreflop,MNombreJoueurs)]
				except:
					pass
			stack+=1
		self.interface.config(state='normal')
		self.interface.insert('end',"Traitement du fichier terminé avec succes\n...")
		self.interface.yview('scroll',1,'units')
		self.interface.config(state='disable')

	def mainsFictifStat(self):
		""""Affichage des donnees résumé des resultats de tournois en argent fictif"""
		self.affichageMainsArgent="Fictif"
		self.handStat()

	def mainsReelStat(self):
		""""Affichage des donnees résumé des resultats de tournois en argent fictif"""
		self.affichageMainsArgent="Réel"
		self.handStat()

	def handStat(self):
		""""Affichage des donnees des mains"""
		self.windowsHand=Tkinter.Toplevel()
		if self.affichageMainsArgent=="Réel":
			self.windowsHand.title("Résultats de mains en argent réel de "+str(self.myLogginName))
		else:
			self.windowsHand.title("Résultats de mains en argent fictif de "+str(self.myLogginName))
		self.iguMains={}
		self.iguMains['En tete']={}
		self.iguMains['En tete']['Container']=Tkinter.Frame(self.windowsHand)
		self.iguMains['Donnees']={}
		self.iguMains['Donnees']['Container']=Tkinter.Frame(self.windowsHand)
		self.iguMains['%']={}
		self.iguMains['%']['Container']=Tkinter.Frame(self.windowsHand)
		self.iguMains['Barre interface']={}
		self.iguMains['Barre interface']['Container']=Tkinter.Frame(self.windowsHand)
		self.iguMains['Deffilement']={}
		self.iguMains['Deffilement']['Container']=Tkinter.Frame(self.windowsHand)
		self.keysHand=['Tournois','Date','Heure','Nombre de joueurs','Tapis','Cartes en main','Tableau','Couché préflop','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu']
		self.keysHandWidth=[10,11,8,7,10,10,15,7,7,7,7,7,7,7]
		keysMainsStack=[1,3,4,20,6,8,11,19,13,14,15,16,17,18]#'Jetons','Tournois','Joueur','Date','Heure','Position','Tapis de depart','Position du button','Cartes en main','Pot final','Rake','Tableau','Statut','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu','Couché préflop','Nombre de joueurs']
		largeurTot=0
		for stack in range(0,len(self.keysHand)):
			self.iguMains['En tete'][self.keysHand[stack]]=Tkinter.Text(self.iguMains['En tete']['Container'])
			self.iguMains['En tete'][self.keysHand[stack]].insert('end',str(self.keysHand[stack]))
			self.iguMains['En tete'][self.keysHand[stack]].config(width=self.keysHandWidth[stack],height=4,state='disable',background='grey')
			self.iguMains['En tete'][self.keysHand[stack]].pack(side='left')
			self.iguMains['Donnees'][self.keysHand[stack]]=Tkinter.Text(self.iguMains['Donnees']['Container'])
			for tupple in self.mains['Listes']:
				if tupple[2]==str(self.myLogginName) and tupple[0]==str(self.affichageMainsArgent):
					if keysMainsStack[stack]==8 and not str(tupple[keysMainsStack[stack]])=="-":
						carte1H=tupple[keysMainsStack[stack]].split(" ")[0][0]
						if tupple[keysMainsStack[stack]].split(" ")[0][1]=="h":
							carte1C=u"\u2661"#chr(3)#str = u"\u2660\u2661\u2662\u2663"
						elif  tupple[keysMainsStack[stack]].split(" ")[0][1]=="d":
							carte1C=u"\u2662"
						elif  tupple[keysMainsStack[stack]].split(" ")[0][1]=="c":
							carte1C=u"\u2663"
						elif  tupple[keysMainsStack[stack]].split(" ")[0][1]=="s":
							carte1C=u"\u2660"
						carte2H=tupple[keysMainsStack[stack]].split(" ")[1][0]
						if tupple[keysMainsStack[stack]].split(" ")[1][1]=="h":
							carte2C=u"\u2661"
						elif  tupple[keysMainsStack[stack]].split(" ")[1][1]=="d":
							carte2C=u"\u2662"
						elif  tupple[keysMainsStack[stack]].split(" ")[1][1]=="c":
							carte2C=u"\u2663"
						elif  tupple[keysMainsStack[stack]].split(" ")[1][1]=="s":
							carte2C=u"\u2660"
						self.iguMains['Donnees'][self.keysHand[stack]].insert('end',str(carte1H)+carte1C+str(carte2H)+carte2C+"\n")
					else:
						self.iguMains['Donnees'][self.keysHand[stack]].insert('end',str(tupple[keysMainsStack[stack]])+"\n")
			self.iguMains['Donnees'][self.keysHand[stack]].config(width=self.keysHandWidth[stack],height=30,state='disable')
			self.iguMains['Donnees'][self.keysHand[stack]].pack(side='left')
			self.iguMains['%'][self.keysHand[stack]]=Tkinter.Text(self.iguMains['%']['Container'])
			self.iguMains['%'][self.keysHand[stack]].config(width=self.keysHandWidth[stack],height=1)
			self.iguMains['%'][self.keysHand[stack]].pack(side='left')
			largeurTot=largeurTot+self.keysHandWidth[stack]
		self.iguMains['En tete']['Container'].grid(row=0,column=0)
		self.iguMains['Donnees']['Container'].grid(row=1,column=0)
		self.iguMains['%']['Container'].grid(row=2,column=0)
		self.iguMains['Deffilement']['Haut']=Tkinter.Button(self.iguMains['Deffilement']['Container'],text="Up",command=self.viewHandUp)
		self.iguMains['Deffilement']['Haut'].pack()
		self.iguMains['Deffilement']['Bas']=Tkinter.Button(self.iguMains['Deffilement']['Container'],text="Down",command=self.viewHandDown)
		self.iguMains['Deffilement']['Bas'].pack()
		self.iguMains['Deffilement']['Container'].grid(rowspan=6,column=1,row=0)
		self.iguMains['Barre interface']['Texte']=Tkinter.Text(self.iguMains['Barre interface']['Container'])
		if self.affichageMainsArgent=="Fictif":
			self.iguMains['Barre interface']['Texte'].insert('end',str(self.joueurs[str(self.myLogginName)]['Resume donnees']['Mains argent fictif'])+" mains analysées pour le joueur "+str(self.myLogginName))
		else:
			self.iguMains['Barre interface']['Texte'].insert('end',str(self.joueurs[str(self.myLogginName)]['Resume donnees']['Mains argent reel'])+" mains analysées pour le joueur "+str(self.myLogginName))
		self.iguMains['Barre interface']['Texte'].config(heigh=1,background='grey',width=largeurTot+12,state='disable')
		self.iguMains['Barre interface']['Texte'].pack()
		self.iguMains['Barre interface']['Container'].grid(row=6,columnspan=2)
		keysStatMains=['Couché préflop','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu']
		self.iguMains['%']['Tableau'].insert('end',"Pourcentages\n")
		self.iguMains['%']['Tableau'].config(state='disable',foreground='red')
		stack=0
		for key in keysStatMains:
			#print str(self.joueurs[str(self.myLogginName)]['Statistique tournois']["Argent "+str(self.affichageTournoisArgent)]['Min'][0])
			self.iguMains['%'][key].insert('end',str(self.joueurs[str(self.myLogginName)]['Statistique mains']["Argent "+str(self.affichageMainsArgent)]['%'][stack]))
			self.iguMains['%'][key].config(state='disable',foreground='blue')
			stack+=1
		for key in self.iguMains['%'].keys():
			try:
				self.iguMains['%'][str(key)].config(state='disable')
			except:
				pass
		self.courbeHandStat()

	def courbeHandStat(self):
		"""Tracé d'un camenbert avec les stats globales des mains"""
		#if True:
		try:
			import pylab
			labels='Couche preflop', 'Couche au flop', 'Couche a la turn', 'Couche a la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu'
			fracs=self.joueurs[str(self.myLogginName)]['Statistique mains']["Argent "+str(self.affichageMainsArgent)]["%"]
			explode=(0.05,0.05, 0.05, 0.05,0.05,0.05,0.05)
			pylab.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%',colors=('b', 'g', 'r', 'c', 'm', 'y', 'w'),)
			pylab.title('Statistiques globales des mains \npour le joueur '+str(self.myLogginName)+' \nen argent '+str(self.affichageMainsArgent), fontsize=12)
			pylab.show()
		except:
			self.interface.config(state='normal')
			self.interface.insert("end","Vous devez télécharger les bibliothèques numpy et matplotlib")
			self.interface.config(state='disable')

	def viewHandUp(self):
		"""Monte dans le tableau des mains"""
		for key in self.keysHand:
			self.iguMains['Donnees'][key].yview('scroll',-20,'units')

	def viewHandDown(self):
		"""Descand dans le tableau des mains"""
		for key in self.keysHand:
			self.iguMains['Donnees'][key].yview('scroll',20,'units')

	def mainsStatAnalyser(self):
		"""Analyse des résultats de tournois : min/max/moy/tot"""
		#['Jetons','Tournois','Joueur','Date','Heure','Position','Tapis de depart','Position du button','Cartes en main','Pot final','Rake','Tableau','Statut','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu','Couché préflop','Nombre de joueurs']\n")
		keysMainsStack=[19,13,14,15,16,17,18]
		self.joueurs[str(self.myLogginName)]['Statistique mains']={}
		self.joueurs[str(self.myLogginName)]['Statistique mains']['Label']=('Couché préflop','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu')
		self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']={}
		self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%']=[0,0,0,0,0,0,0]
		self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']={}
		self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%']=[0,0,0,0,0,0,0]
		cptReel=0
		cptFictif=0
		for tupple in self.mains['Listes']:
			if tupple[0]=="Fictif" and tupple[2]==str(self.myLogginName):
				stack=0
				for stat in self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%']:
					mark=keysMainsStack[stack]
					if not tupple[mark]=="-":
						cptFictif+=1
						self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%'][stack])+float(tupple[mark])
					stack+=1
			if tupple[0]=="Réel" and tupple[2]==str(self.myLogginName):
				stack=0
				for stat in self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%']:
					mark=keysMainsStack[stack]
					if not tupple[mark]=="-":
						cptReel+=1
						self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'][stack]=float(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'][stack])+float(tupple[mark])
					stack+=1
		if cptReel:
			for stack in range(0,len(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'])):
				#print self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'][stack], cptReel
				self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'][stack]=100*float(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%'][stack])/float(cptReel)*float(len(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Réel']['%']))
		if cptFictif:
			for stack in range(0,len(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%'])):
				self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%'][stack]=100*float(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%'][stack])/float(cptFictif)*float(len(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent Fictif']['%']))

	def joueurReelStat(self):
		"""Affichage des statistiques générales pour le joueur en argent reel"""
		self.joueurArgentStat="Réel"
		self.joueurStat()

	def joueurFictifStat(self):
		"""Affichage des statistiques générales pour le joueur en argent fictif"""
		self.joueurArgentStat="Fictif"
		self.joueurStat()

	def joueurStat(self):
		"""Affichage des statistiques générales pour le joueur"""
		self.interface.config(state='normal')
		self.interface.insert('end',"Résultats généraux pour les mains de "+str(self.myLogginName)+"\n...")
		self.interface.insert('end',"\tCouché préflop : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][0])+"%\n...")
		self.interface.insert('end',"\tCouché au flop : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][1])+"%\n...")
		self.interface.insert('end',"\tCouché à la turn : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][2])+"%\n...")
		self.interface.insert('end',"\tCouché à la river : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][3])+"%\n...")
		self.interface.insert('end',"\tGagne sans montrer son jeu : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][4])+"%\n...")
		self.interface.insert('end',"\tGagne en montrant son jeu : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][5])+"%\n...")
		self.interface.insert('end',"\tPerd en montrant son jeu : "+str(self.joueurs[str(self.myLogginName)]['Statistique mains']['Argent '+str(self.joueurArgentStat)]['%'][6])+"%\n...")
		self.interface.insert('end',"Résultats généraux pour les tournois de "+str(self.myLogginName)+"\n...")
		self.interface.insert('end',"\t Entrée :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][0])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][0])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][0])+"\n...")
		self.interface.insert('end',"\t\t total : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Tot'][0])+"\n...")
		self.interface.insert('end',"\t Rake :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][1])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][1])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][1])+"\n...")
		self.interface.insert('end',"\t\t total : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Tot'][1])+"\n...")
		self.interface.insert('end',"\t Nombre de joueurs :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][2])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][2])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][2])+"\n...")
		self.interface.insert('end',"\t Position finale sur 10 :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][3])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][3])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][3])+"\n...")
		self.interface.insert('end',"\t Sortie :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][4])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][4])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][4])+"\n...")
		self.interface.insert('end',"\t\t total : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Tot'][4])+"\n...")
		self.interface.insert('end',"\t Gains :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][5])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][5])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][5])+"\n...")
		self.interface.insert('end',"\t\t total : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Tot'][5])+"\n...")
		self.interface.insert('end',"\t ROI :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][6])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][6])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][6])+"\n...")
		self.interface.insert('end',"\t $/h :\n...")
		self.interface.insert('end',"\t\t minimum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Min'][7])+"\n...")
		self.interface.insert('end',"\t\t maximum : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Max'][7])+"\n...")
		self.interface.insert('end',"\t\t moyen : "+str(self.joueurs[str(self.myLogginName)]['Statistique tournois']['Argent '+str(self.joueurArgentStat)]['Moy'][7])+"\n...")
		self.interface.yview('scroll',50,'units')
		self.interface.config(state='disable')

	def evolutionReelTournois(self):
		"""Affichage de la courbe d'évolution de la banque en foncion du temps en argent réel"""
		self.courbeTournoisArgent="Réel"
		self.evolutionTracesTournois()

	def evolutionFictifTournois(self):
		"""Affichage de la courbe d'évolution de la banque en foncion du temps en argent fictif"""
		self.courbeTournoisArgent="Fictif"
		self.evolutionTracesTournois()

	def evolutionTracesTournois(self):
		"""Traces de courbes"""
		#if True:
		try:
			import matplotlib.pyplot as plt
			from matplotlib.dates import DateFormatter
			import pylab
			#Organisation par heure
			self.tournois['Listes'].sort(lambda a,b:cmp(a[5],b[5]))
			#Organisation par date
			self.tournois['Listes'].sort(lambda a,b:cmp(a[13],b[13]))
			#caisse en focntion du temps
			dateX=[]
			gainsTemps=[]
			caisseTemps=[]
			#Tournois :: [('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h')]
			for tupple in self.tournois['Listes']:
				if tupple[4]==str(self.myLogginName) and tupple[15]==str(self.courbeTournoisArgent):
					if tupple[9]=="-":
						pass
					else:
						if int(tupple[5].split(":")[0])==24:
							dateX+=[datetime.datetime(int(tupple[13].split("/")[0]),int(tupple[13].split("/")[1]),int(int(tupple[13].split("/")[2])),int("00"),int(tupple[5].split(":")[1]),int("00"))+datetime.timedelta(hours=24)]
						else:
							dateX+=[datetime.datetime(int(tupple[13].split("/")[0]),int(tupple[13].split("/")[1]),int(tupple[13].split("/")[2]),int(tupple[5].split(":")[0]),int(tupple[5].split(":")[1]),int("00"))]
						gainsTemps+=[tupple[9]]
			temp=0
			for gains in gainsTemps:
				caisseTemps+=[temp+gains]
				temp+=gains
			formatDate=DateFormatter('%d/%m/%y')
			ax=pylab.subplot(211)
			pylab.plot_date(pylab.date2num(dateX),caisseTemps,linestyle='-')
			ax.xaxis.set_major_formatter(formatDate)
			plt.xlabel('Date de fin du tournois',fontsize=8)
			labels=ax.get_xticklabels()
			pylab.setp(labels, rotation=30, fontsize=8)
			ax.xaxis.set_major_formatter(formatDate)
			plt.ylabel('Argent en caisse (sommme des gains)',fontsize=8)
			plt.title('Evolution du budjet en caisse en argent '+str(self.courbeTournoisArgent)+' pour le joueur '+str(self.myLogginName),fontsize=10)
			plt.grid(True)
			ay=pylab.subplot(212)
			pylab.plot(caisseTemps,'bo-')
			pylab.xlabel("Nombre de tournois joues",fontsize=8)
			pylab.ylabel("Argent en caisse (somme des gains)",fontsize=8)
			pylab.grid(True)
			pylab.show()
		except:
			self.interface.config(state='normal')
			self.interface.insert("end","Vous devez télécharger les bibliothèques numpy et matplotlib")
			self.interface.config(state='disable')

	def evolutionFrequencePositionReel(self):
		"""Tracé de l'histogramme de la fréquence de la position finale sur 10 en argent reel"""
		self.courbeFrequenceArgent="Réel"
		self.evolutionFrequencePosition()

	def evolutionFrequencePositionFictif(self):
		"""Tracé de l'histogramme de la fréquence de la position finale sur 10 en argent reel"""
		self.courbeFrequenceArgent="Fictif"
		self.evolutionFrequencePosition()

	def evolutionFrequencePosition(self):
		"""Tracé de l'histogramme de la fréquence de la position finale sur 10"""
		#if True:
		try:
			import pylab
			yy=[]
			#Tournois :: [('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h')]
			for tupple in self.tournois['Listes']:
				if tupple[4]==str(self.myLogginName) and tupple[15]==str(self.courbeFrequenceArgent):
					if tupple[14]=="-":
						pass
					else:
						yy+=[int(float(tupple[14])/float(1))]
			pylab.hist(yy,100)
			pylab.xlabel('Position finale sur 10 joueurs',fontsize=8)
			pylab.ylabel("Frequence d'obtention de la position",fontsize=8)
			pylab.title("Repartition de la position finale sur 10 sur l'ensemble des tournois en argent "+str(self.courbeFrequenceArgent)+" pour le joueur "+str(self.myLogginName),fontsize=10)
			pylab.grid(True)
			pylab.show()
		except:
			self.interface.config(state='normal')
			self.interface.insert("end","Vous devez télécharger les bibliothèques numpy et matplotlib")
			self.interface.config(state='disable')

	def entreeStatReel(self):
		"""Calcul des stats en argent reel en fonction du pris de l'entrée"""
		self.entreeStatArgent="Réel"
		self.entreeStat()

	def entreeStatFictif(self):
		"""Calcul des stats en argent fictif en fonction du pris de l'entrée"""
		self.entreeStatArgent="Fictif"
		self.entreeStat()

	def entreeStat(self):
		"""Calcul des stats en fonction du pris de l'entrée"""
		#('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h')]]
		self.tournois['Listes'].sort(lambda a,b:cmp(a[3],b[3]))
		entreeStatResume={}
		for tupple in self.tournois['Listes']:
			if tupple[4]==str(self.myLogginName) and tupple[15]==str(self.entreeStatArgent):
				if not entreeStatResume.keys().count(str(tupple[3])):
					entreeStatResume[str(tupple[3])]={}
					entreeStatResume[str(tupple[3])]['Min']=["-","-","-"]
					entreeStatResume[str(tupple[3])]['Max']=["-","-","-"]
					entreeStatResume[str(tupple[3])]['Moy']=["-","-","-"]
					entreeStatResume[str(tupple[3])]['Tot']=[0,0,0]
					entreeStatResume[str(tupple[3])]['Compteur']=0
				if not tupple[9]=="-" and not tupple[1]=="-" and not tupple[14]=="-":
					entreeStatResume[str(tupple[3])]['Compteur']+=1
					if not str(entreeStatResume[str(tupple[3])]['Min'][0])=="-":
						if float(entreeStatResume[str(tupple[3])]['Min'][0])>=float(tupple[9]):#gains
							entreeStatResume[str(tupple[3])]['Min'][0]=float(tupple[9])
						if float(entreeStatResume[str(tupple[3])]['Max'][0])<=float(tupple[9]):#gains
							entreeStatResume[str(tupple[3])]['Max'][0]=float(tupple[9])
					else:
						entreeStatResume[str(tupple[3])]['Max'][0]=float(tupple[9])
						entreeStatResume[str(tupple[3])]['Min'][0]=float(tupple[9])
					entreeStatResume[str(tupple[3])]['Tot'][0]=float(entreeStatResume[str(tupple[3])]['Tot'][0])+float(tupple[9])
					if not str(entreeStatResume[str(tupple[3])]['Min'][1])=="-":
						if float(entreeStatResume[str(tupple[3])]['Min'][1])>=float(tupple[1]):#roi
							entreeStatResume[str(tupple[3])]['Min'][1]=float(tupple[1])
						if float(entreeStatResume[str(tupple[3])]['Max'][1])<=float(tupple[1]):#roi
							entreeStatResume[str(tupple[3])]['Max'][1]=float(tupple[1])
					else:
						entreeStatResume[str(tupple[3])]['Min'][1]=float(tupple[1])
						entreeStatResume[str(tupple[3])]['Max'][1]=float(tupple[1])
					entreeStatResume[str(tupple[3])]['Tot'][1]=float(entreeStatResume[str(tupple[3])]['Tot'][1])+float(tupple[1])
					if not str(entreeStatResume[str(tupple[3])]['Min'][2])=="-":
						if float(entreeStatResume[str(tupple[3])]['Min'][2])>=float(tupple[14]):#position sur 10
							entreeStatResume[str(tupple[3])]['Min'][2]=float(tupple[14])
						if float(entreeStatResume[str(tupple[3])]['Max'][2])<=float(tupple[14]):#position sur 10
							entreeStatResume[str(tupple[3])]['Max'][2]=float(tupple[14])
					else:
						entreeStatResume[str(tupple[3])]['Max'][2]=float(tupple[14])
						entreeStatResume[str(tupple[3])]['Min'][2]=float(tupple[14])
					entreeStatResume[str(tupple[3])]['Tot'][2]=float(entreeStatResume[str(tupple[3])]['Tot'][2])+float(tupple[14])
		for key in entreeStatResume.keys():
			try:
				entreeStatResume[str(key)]['Moy'][0]=int(float(entreeStatResume[str(key)]['Tot'][0])/float(entreeStatResume[str(key)]['Compteur']))
				entreeStatResume[str(key)]['Moy'][1]=int(float(entreeStatResume[str(key)]['Tot'][1])/float(entreeStatResume[str(key)]['Compteur']))
				entreeStatResume[str(key)]['Moy'][2]=int(float(entreeStatResume[str(key)]['Tot'][2])/float(entreeStatResume[str(key)]['Compteur']))
			except:
				entreeStatResume[str(key)]['Moy'][0]="-"
				entreeStatResume[str(key)]['Moy'][1]="-"
				entreeStatResume[str(key)]['Moy'][2]="-"
		try:
			self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)]={}
		except:
			self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']={}
			self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)]={}
		for key in entreeStatResume.keys():
			self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][str(key)]=entreeStatResume[str(key)]

	def entreeStatReelView(self):
		"""Calcul des stats en argent reel en fonction du pris de l'entrée"""
		self.entreeStatArgent="Réel"
		self.affichageEntreeStat()

	def entreeStatFictifView(self):
		"""Calcul des stats en argent fictif en fonction du pris de l'entrée"""
		self.entreeStatArgent="Fictif"
		self.affichageEntreeStat()

	def affichageEntreeStat(self):
		"""Affichage des données calculées en fonction du prix de l'entrée"""
		self.iguEntreeStat={}
		self.windowsAffichageEntreeStat=Tkinter.Toplevel()
		self.windowsAffichageEntreeStat.title("Résumé des résultats de tournois en fonction du prix de l'entrée en argent "+str(self.entreeStatArgent)+" pour le joueur "+str(self.myLogginName))
		self.containerLabel=Tkinter.Frame(self.windowsAffichageEntreeStat)
		self.iguEntreeStat["Label"]={}
		self.iguEntreeStat["Label"]["Entrée"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Entrée"].insert("end","Entrée"+"\n")
		self.iguEntreeStat["Label"]["Entrée"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Entrée"].pack(side="left")
		self.iguEntreeStat["Label"]["Nombre de parties"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Nombre de parties"].insert("end","Nombre de parties"+"\n")
		self.iguEntreeStat["Label"]["Nombre de parties"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Nombre de parties"].pack(side="left")
		self.iguEntreeStat["Label"]["Gains min"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Gains min"].insert("end","Gains min"+"\n")
		self.iguEntreeStat["Label"]["Gains min"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Gains min"].pack(side="left")
		self.iguEntreeStat["Label"]["Gains max"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Gains max"].insert("end","Gains max"+"\n")
		self.iguEntreeStat["Label"]["Gains max"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Gains max"].pack(side="left")
		self.iguEntreeStat["Label"]["Gains moy"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Gains moy"].insert("end","Gains moy"+"\n")
		self.iguEntreeStat["Label"]["Gains moy"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Gains moy"].pack(side="left")
		self.iguEntreeStat["Label"]["Gains tot"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Gains tot"].insert("end","Gains tot"+"\n")
		self.iguEntreeStat["Label"]["Gains tot"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Gains tot"].pack(side="left")
		self.iguEntreeStat["Label"]["ROI min"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["ROI min"].insert("end","ROI min"+"\n")
		self.iguEntreeStat["Label"]["ROI min"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["ROI min"].pack(side="left")
		self.iguEntreeStat["Label"]["ROI max"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["ROI max"].insert("end","ROI max"+"\n")
		self.iguEntreeStat["Label"]["ROI max"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["ROI max"].pack(side="left")
		self.iguEntreeStat["Label"]["ROI moy"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["ROI moy"].insert("end","ROI moy"+"\n")
		self.iguEntreeStat["Label"]["ROI moy"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["ROI moy"].pack(side="left")
		self.iguEntreeStat["Label"]["ROI tot"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["ROI tot"].insert("end","ROI tot"+"\n")
		self.iguEntreeStat["Label"]["ROI tot"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["ROI tot"].pack(side="left")
		self.iguEntreeStat["Label"]["Position finale sur 10 min"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Position finale sur 10 min"].insert("end","Position finale sur 10 min"+"\n")
		self.iguEntreeStat["Label"]["Position finale sur 10 min"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Position finale sur 10 min"].pack(side="left")
		self.iguEntreeStat["Label"]["Position finale sur 10 max"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Position finale sur 10 max"].insert("end","Position finale sur 10 max"+"\n")
		self.iguEntreeStat["Label"]["Position finale sur 10 max"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Position finale sur 10 max"].pack(side="left")
		self.iguEntreeStat["Label"]["Position finale sur 10 moy"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Position finale sur 10 moy"].insert("end","Position finale sur 10 moy"+"\n")
		self.iguEntreeStat["Label"]["Position finale sur 10 moy"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Position finale sur 10 moy"].pack(side="left")
		self.iguEntreeStat["Label"]["Position finale sur 10 tot"]=Tkinter.Text(self.containerLabel)
		self.iguEntreeStat["Label"]["Position finale sur 10 tot"].insert("end","Position finale sur 10 tot"+"\n")
		self.iguEntreeStat["Label"]["Position finale sur 10 tot"].config(width=10,heigh=3,foreground="blue",state="disable")
		self.iguEntreeStat["Label"]["Position finale sur 10 tot"].pack(side="left")
		self.containerLabel.pack()
		self.container=Tkinter.Frame(self.windowsAffichageEntreeStat)
		self.iguEntreeStat["Entrée"]=Tkinter.Text(self.container)
		self.iguEntreeStat["Entrée"].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys()))
		self.iguEntreeStat["Entrée"].pack(side="left")
		self.iguEntreeStat["Nombre de parties"]=Tkinter.Text(self.container)
		self.iguEntreeStat["Nombre de parties"].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys()))
		self.iguEntreeStat["Nombre de parties"].pack(side="left")
		for key in ["Gains","ROI","Position finale sur 10"]:
			self.iguEntreeStat[str(key)]={}
			for keys in ['Min','Max','Moy','Tot']:
				self.iguEntreeStat[str(key)][str(keys)]=Tkinter.Text(self.container)
				self.iguEntreeStat[str(key)][str(keys)].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys()))
				self.iguEntreeStat[str(key)][str(keys)].pack(side="left")
		self.container.pack()
		for keys in self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys():
			self.iguEntreeStat["Entrée"].insert('end',str(keys)+"\n")
			self.iguEntreeStat["Nombre de parties"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Compteur"])+"\n")
			self.iguEntreeStat["Gains"]["Min"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Min"][0])+"\n")
			self.iguEntreeStat["Gains"]["Max"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Max"][0])+"\n")
			self.iguEntreeStat["Gains"]["Moy"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Moy"][0])+"\n")
			self.iguEntreeStat["Gains"]["Tot"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Tot"][0])+"\n")
			self.iguEntreeStat["ROI"]["Min"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Min"][1])+"\n")
			self.iguEntreeStat["ROI"]["Max"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Max"][1])+"\n")
			self.iguEntreeStat["ROI"]["Moy"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Moy"][1])+"\n")
			self.iguEntreeStat["ROI"]["Tot"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Tot"][1])+"\n")
			self.iguEntreeStat["Position finale sur 10"]["Min"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Min"][2])+"\n")
			self.iguEntreeStat["Position finale sur 10"]["Max"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Max"][2])+"\n")
			self.iguEntreeStat["Position finale sur 10"]["Moy"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Moy"][2])+"\n")
			self.iguEntreeStat["Position finale sur 10"]["Tot"].insert('end',str(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][keys]["Tot"][2])+"\n")
		for key in self.iguEntreeStat.keys():
			for keys in self.iguEntreeStat[str(key)].keys():
				try:
					self.iguEntreeStat[str(key)][str(keys)].config(state='disable')
				except:
					self.iguEntreeStat[str(key)].config(state='disable')
		self.evolutionEntreeStat()

	def evolutionEntreeStat(self):
		"""Tracé de l'histogramme des gains moyen/roi moyen/position finale sur 10 moyen en fonction de l'entrée"""
		#if True:
		try:
			import pylab
			import numpy
			N=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys())
			ind=numpy.arange(N)    # the x locations for the groups
			Entree=[]
			GainsMoy=[]
			ROIMoy=[]
			PosFinal100Moy=[]
			NbrTournois=[]
			tupple=[]
			stack=0
			for entree in self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)].keys():
				Entree+=[float(entree)]
				GainsMoy+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][str(entree)]['Moy'][0]]
				ROIMoy+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][str(entree)]['Moy'][1]]
				PosFinal100Moy+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][str(entree)]['Moy'][2]]
				NbrTournois+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeStatArgent)][entree]["Compteur"]]
				tupple+=[(Entree[stack],GainsMoy[stack],ROIMoy[stack],PosFinal100Moy[stack],NbrTournois[stack])]
				stack+=1
			tupple.sort(lambda a,b:cmp(a[0],b[0]))
			Entree=[]
			GainsMoy=[]
			ROIMoy=[]
			PosFinal100Moy=[]
			NbrTournois=[]
			for entree in tupple:
				try:
					Entree+=[str(entree[0])]
					GainsMoy+=[float(entree[1])]
					ROIMoy+=[float(entree[2])]
					PosFinal100Moy+=[float(entree[3])]
					NbrTournois+=[float(entree[4])]
				except:
					Entree+=[str(entree[0])]
					GainsMoy+=[0]
					ROIMoy+=[0]
					PosFinal100Moy+=[0]
					NbrTournois+=[0]
			fig=pylab.figure()
			ax=fig.add_subplot(141)
			width=0.35#the width of the bars
			p0=ax.bar(ind, GainsMoy, width, color='b', bottom=0)
			ax.set_xticks(ind)
			ax.set_xticklabels(Entree)
			ax.set_xlabel("Entree")
			ax.autoscale_view()
			ax.set_title("Evolution des gains moyens\n en fonction de l'entree \nen argent "+str(self.entreeStatArgent)+"\n pour le joueur "+str(self.myLogginName),fontsize=10)
			ax.grid(True)
			ay=fig.add_subplot(142)
			width=0.35#the width of the bars
			p1=ay.bar(ind, ROIMoy, width, color='r', bottom=0)
			ay.set_xticks(ind)
			ay.set_xticklabels(Entree)
			ay.set_xlabel("Entree")
			ay.autoscale_view()
			ay.set_title("Evolution du ROI moyen\n en fonction de l'entree \nen argent "+str(self.entreeStatArgent)+"\n pour le joueur "+str(self.myLogginName),fontsize=10)
			ay.grid(True)
			az=fig.add_subplot(143)
			width=0.35#the width of the bars
			p2=az.bar(ind, PosFinal100Moy, width, color='g', bottom=0)
			az.set_xticks(ind)
			az.set_xticklabels(Entree)
			az.set_xlabel("Entree")
			az.autoscale_view()
			az.set_title("Evolution de la position finale moyenne\n en fonction de l'entree \nen argent "+str(self.entreeStatArgent)+"\n pour le joueur "+str(self.myLogginName),fontsize=10)
			az.grid(True)
			aw=fig.add_subplot(144)
			width=0.35#the width of the bars
			p3=aw.bar(ind, NbrTournois, width, color='y', bottom=0)
			aw.set_xticks(ind)
			aw.set_xticklabels(Entree)
			aw.set_xlabel("Entree")
			aw.autoscale_view()
			aw.set_title("Nombre de partie jouees\n en fonction de l'entree \nen argent "+str(self.entreeStatArgent)+"\n pour le joueur "+str(self.myLogginName),fontsize=10)
			aw.grid(True)
			pylab.show()
		except:
			self.interface.config(state='normal')
			self.interface.insert("end","Vous devez télécharger les bibliothèques numpy et matplotlib")
			self.interface.config(state='disable')

	def entreeMainsStatReel(self):
		"""Evolution des stats des mains en fonctions de l'entrée en argent reel"""
		self.entreeMainsArgent="Réel"
		self.entreeMainsStat()

	def entreeMainsStatFictif(self):
		"""Evolution des stats des mains en fonctions de l'entrée en argent fictif"""
		self.entreeMainsArgent="Fictif"
		self.entreeMainsStat()

	def entreeMainsStat(self):
		"""Evolution des stats des mains en fonctions de l'entrée"""
		#mains['Labels']=['Jetons','Tournois','Joueur','Date','Heure','Position','Tapis de depart','Position du button','Cartes en main','Pot final','Rake','Tableau','Statut','Couché au flop','Couché à la turn','Couché à la river','Gagne sans montrer son jeu','Gagne en montrant son jeu','Perd en montrant son jeu','Couché préflop','Nombre de joueurs']
		#tournois['Labels']=[('Nombre de joueurs','ROI','Heure de debut','Entree','Joueur','Heure de fin','Date de debut','Rake','Sortie','Gains','Position finale','Temps de jeu','Tournois','Date de fin','Position finale sur 10','Jetons','$/h')]
		entree=[]
		fPreflop=[]
		fFlop=[]
		fTurn=[]
		fRiver=[]
		wWithoutShow=[]
		wWithShow=[]
		lWithShow=[]
		tupple=[]
		for tuppleMains in self.mains['Listes']:
			if tuppleMains[2]==str(self.myLogginName) and tuppleMains[0]==str(self.entreeMainsArgent):
				tournois=tuppleMains[1]
				for tuppleTournois in self.tournois['Listes']:
					if str(tuppleTournois[12])==str(tournois):
						if not tuppleMains[15]=="-":
							entree+=[float(tuppleTournois[3])]
							fPreflop+=[str(tuppleMains[19])]
							fFlop+=[str(tuppleMains[13])]
							fTurn+=[str(tuppleMains[14])]
							fRiver+=[str(tuppleMains[15])]
							wWithoutShow+=[str(tuppleMains[16])]
							wWithShow+=[str(tuppleMains[17])]
							lWithShow+=[str(tuppleMains[18])]
							tupple+=(entree,fPreflop,fFlop,fTurn,fRiver,wWithoutShow,wWithShow,lWithShow)
		#ici on a des listes de resultats
		entreeMainsStat={}
		stack=0
		for valeur in entree:
			try:
				if not entreeMainsStat.keys().count(valeur):
					entreeMainsStat[valeur]=[0,0,0,0,0,0,0,0]
				entreeMainsStat[valeur][0]=int(entreeMainsStat[valeur][0])+int(fPreflop[stack])
				entreeMainsStat[valeur][1]=int(entreeMainsStat[valeur][1])+int(fFlop[stack])
				entreeMainsStat[valeur][2]=int(entreeMainsStat[valeur][2])+int(fTurn[stack])
				entreeMainsStat[valeur][3]=int(entreeMainsStat[valeur][3])+int(fRiver[stack])
				entreeMainsStat[valeur][4]=int(entreeMainsStat[valeur][4])+int(wWithoutShow[stack])
				entreeMainsStat[valeur][5]=int(entreeMainsStat[valeur][5])+int(wWithShow[stack])
				entreeMainsStat[valeur][6]=int(entreeMainsStat[valeur][6])+int(lWithShow[stack])
				entreeMainsStat[valeur][7]=int(entreeMainsStat[valeur][7])+1
				stack+=1
			except:
				pass
		try:
			self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)]={}
		except:
			self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']={}
			self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Label"]=["Entrée","Couché préflop","Couché au flop","Couché à la turn","Couché à la river","Gagne en montrant son jeu","Gagne sans montrer son jeu","Perd en montrant son jeu","Nombre de mains"]
			self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)]={}
		for key in entreeMainsStat.keys():
			try:
				entreeMainsStat[key][0]=100*float(entreeMainsStat[key][0])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][1]=100*float(entreeMainsStat[key][1])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][2]=100*float(entreeMainsStat[key][2])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][3]=100*float(entreeMainsStat[key][3])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][4]=100*float(entreeMainsStat[key][4])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][5]=100*float(entreeMainsStat[key][5])/float(entreeMainsStat[key][7])
				entreeMainsStat[key][6]=100*float(entreeMainsStat[key][6])/float(entreeMainsStat[key][7])
			except:
				pass
			self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][key]=[(entreeMainsStat[key][0],entreeMainsStat[key][1],entreeMainsStat[key][2],entreeMainsStat[key][3],entreeMainsStat[key][4],entreeMainsStat[key][5],entreeMainsStat[key][6],entreeMainsStat[key][7])]

	def entreeMainsStatReelView(self):
		"""Evolution des stats des mains en fonctions de l'entrée en argent reel"""
		self.entreeMainsArgent="Réel"
		self.viewEntreeMainsStat()

	def entreeMainsStatFictifView(self):
		"""Evolution des stats des mains en fonctions de l'entrée en argent fictif"""
		self.entreeMainsArgent="Fictif"
		self.viewEntreeMainsStat()

	def viewEntreeMainsStat(self):
		"""Affichage des résultats des stats des mains en foncitons de l'entree"""
		#["Entrée","Couché préflop","Couché au flop","Couché à la turn","Couché à la river","Gagne en montrant son jeu","Gagne sans montrer son jeu","Perd en montrant son jeu","Nombre de mains"]
		iguEntreeStat={}
		windowsAffichageEntreeStatHand=Tkinter.Toplevel()
		windowsAffichageEntreeStatHand.title("Résumé des résultats des mains en fonction du prix de l'entrée en argent "+str(self.entreeMainsArgent)+" pour le joueur "+str(self.myLogginName))
		containerLabel=Tkinter.Frame(windowsAffichageEntreeStatHand)
		iguEntreeStat["Label"]={}
		iguEntreeStat["Label"]["Entrée"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Entrée"].insert("end","Entrée"+"\n")
		iguEntreeStat["Label"]["Entrée"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Entrée"].pack(side="left")
		iguEntreeStat["Label"]["Nombre de mains"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Nombre de mains"].insert("end","Nombre de mains"+"\n")
		iguEntreeStat["Label"]["Nombre de mains"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Nombre de mains"].pack(side="left")
		iguEntreeStat["Label"]["Couché préflop"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Couché préflop"].insert("end","Couché préflop"+"\n")
		iguEntreeStat["Label"]["Couché préflop"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Couché préflop"].pack(side="left")
		iguEntreeStat["Label"]["Couché au flop"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Couché au flop"].insert("end","Couché au flop"+"\n")
		iguEntreeStat["Label"]["Couché au flop"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Couché au flop"].pack(side="left")
		iguEntreeStat["Label"]["Couché à la turn"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Couché à la turn"].insert("end","Couché à la turn"+"\n")
		iguEntreeStat["Label"]["Couché à la turn"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Couché à la turn"].pack(side="left")
		iguEntreeStat["Label"]["Couché à la river"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Couché à la river"].insert("end","Couché à la river"+"\n")
		iguEntreeStat["Label"]["Couché à la river"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Couché à la river"].pack(side="left")
		iguEntreeStat["Label"]["Gagne sans montrer son jeu"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Gagne sans montrer son jeu"].insert("end","Gagne sans montrer son jeu"+"\n")
		iguEntreeStat["Label"]["Gagne sans montrer son jeu"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Gagne sans montrer son jeu"].pack(side="left")
		iguEntreeStat["Label"]["Gagne en montrant son jeu"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Gagne en montrant son jeu"].insert("end","Gagne en montrant son jeu"+"\n")
		iguEntreeStat["Label"]["Gagne en montrant son jeu"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Gagne en montrant son jeu"].pack(side="left")
		iguEntreeStat["Label"]["Perd en montrant son jeu"]=Tkinter.Text(containerLabel)
		iguEntreeStat["Label"]["Perd en montrant son jeu"].insert("end","Perd en montrant son jeu"+"\n")
		iguEntreeStat["Label"]["Perd en montrant son jeu"].config(width=10,heigh=3,foreground="blue",state="disable")
		iguEntreeStat["Label"]["Perd en montrant son jeu"].pack(side="left")
		containerLabel.pack()
		container=Tkinter.Frame(windowsAffichageEntreeStatHand)
		iguEntreeStat["Entrée"]=Tkinter.Text(container)
		iguEntreeStat["Entrée"].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys()))
		iguEntreeStat["Entrée"].pack(side="left")
		iguEntreeStat["Nombre de parties"]=Tkinter.Text(container)
		iguEntreeStat["Nombre de parties"].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys()))
		iguEntreeStat["Nombre de parties"].pack(side="left")
		for key in ["Couché préflop","Couché au flop","Couché à la turn","Couché à la river","Gagne sans montrer son jeu","Gagne en montrant son jeu","Perd en montrant son jeu"]:
			iguEntreeStat[str(key)]={}
			iguEntreeStat[str(key)]=Tkinter.Text(container)
			iguEntreeStat[str(key)].config(width=10,heigh=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys()))
			iguEntreeStat[str(key)].pack(side="left")
		container.pack()
		for keys in self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys():
			iguEntreeStat["Entrée"].insert('end',str(keys)+"\n")
			iguEntreeStat["Nombre de parties"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][7]))+"\n")
			iguEntreeStat["Couché préflop"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][0]))[0:5]+"\n")
			iguEntreeStat["Couché au flop"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][1]))[0:5]+"\n")
			iguEntreeStat["Couché à la turn"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][2]))[0:5]+"\n")
			iguEntreeStat["Couché à la river"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][3]))[0:5]+"\n")
			iguEntreeStat["Gagne sans montrer son jeu"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][4]))[0:5]+"\n")
			iguEntreeStat["Gagne en montrant son jeu"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][5]))[0:5]+"\n")
			iguEntreeStat["Perd en montrant son jeu"].insert('end',str((self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][keys][0][6]))[0:5]+"\n")
		for key in iguEntreeStat.keys():
			for keys in iguEntreeStat[str(key)].keys():
				try:
					iguEntreeStat[str(key)][str(keys)].config(state='disable')
				except:
					iguEntreeStat[str(key)].config(state='disable')
		self.evolutionEntreeMainsStat()

	def evolutionEntreeMainsStat(self):
		"""Tracé de l'évolutiond es stats du joueur en fonction de l'entrée"""
		#if True:
		try:
			import pylab
			import numpy
			N=7
			N2=len(self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys())
			ind=numpy.arange(N)    # the x locations for the groups
			ind2=numpy.arange(N2)    # the x locations for the groups
			Entree=[]
			CouchePreflop=[]
			CoucheFlop=[]
			CoucheTurn=[]
			CoucheRiver=[]
			GagneSansMontre=[]
			GagneMontre=[]
			PerdMontre=[]
			NombreMains=[]
			tupple=[]
			stack=0
			for entree in self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)].keys():
				Entree+=[float(entree)]
				CouchePreflop+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][0]]
				CoucheFlop+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][1]]
				CoucheTurn+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][2]]
				CoucheRiver+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][3]]
				GagneSansMontre+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][4]]
				GagneMontre+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][5]]
				PerdMontre+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][6]]
				NombreMains+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques mains']["Argent "+str(self.entreeMainsArgent)][(entree)][0][7]]
				tupple+=[(Entree[stack],CouchePreflop[stack],CoucheFlop[stack],CoucheTurn[stack],CoucheRiver[stack],GagneSansMontre[stack],GagneMontre[stack],PerdMontre[stack],NombreMains[stack])]
				stack+=1
			tupple.sort(lambda a,b:cmp(a[0],b[0]))
			Entree=[]
			CouchePreflop=[]
			CoucheFlop=[]
			CoucheTurn=[]
			CoucheRiver=[]
			GagneSansMontre=[]
			GagneMontre=[]
			PerdMontre=[]
			NombreMains=[]
			for entree in tupple:
				Entree+=[str(entree[0])]
				CouchePreflop+=[float(entree[1])]
				CoucheFlop+=[float(entree[2])]
				CoucheTurn+=[float(entree[3])]
				CoucheRiver+=[float(entree[4])]
				GagneSansMontre+=[float(entree[5])]
				GagneMontre+=[float(entree[6])]
				PerdMontre+=[float(entree[7])]
				NombreMains+=[float(entree[8])]
			fig=pylab.figure()
			ax=fig.add_subplot(211)
			width=0.1#the width of the bars
			p={}
			tuppleP=()
			legendP=[]
			couleurP=['r','g','b','y','k','w','r','g','b','y','k','w']
			listeP=[]
			for stack in range(0,len(Entree)):
				tupples=[(CouchePreflop[stack]),(CoucheFlop[stack]),(CoucheTurn[stack]),(CoucheRiver[stack]),(GagneSansMontre[stack]),(GagneMontre[stack]),(PerdMontre[stack])]
				p[stack]=ax.bar(ind+stack*width, tupples , width, bottom=0,color=couleurP[stack])
				legendP+=[Entree[stack]]
				listeP+=[p[stack][0]]
			ax.set_xticks(ind)
			Labels=("Couche preflop","Couche au flop","Couche a la turn","Couche a la river","Gagne sans montrer\n son jeu","Gagne en montrant\n son jeu","Perd en montrant\n son jeu")
			ax.set_xticklabels(Labels)
			ax.set_title("Evolution des statistiques des mains en fonction de l'entree \nen argent "+str(self.entreeMainsArgent)+" pour le joueur "+str(self.myLogginName),fontsize=10)
			ax.legend(listeP,legendP,shadow=True,markerscale=1)
			ax.grid(True)
			ay=fig.add_subplot(223)
			width=0.5#the width of the bars
			p1=ay.bar(ind2, NombreMains, width, color='b', bottom=0)
			ay.set_xticks(ind)
			ay.set_xticklabels(Entree)
			ay.set_title("Evolution du nombre de mains en fonction de l'entree \nen argent "+str(self.entreeMainsArgent)+" pour le joueur "+str(self.myLogginName),fontsize=10)
			ay.grid(True)
			Entree=[]
			ROIMoy=[]
			NbrTournois=[]
			tupple=[]
			stack=0
			for entree in self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeMainsArgent)].keys():
				Entree+=[float(entree)]
				ROIMoy+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeMainsArgent)][str(entree)]['Moy'][1]]
				NbrTournois+=[self.joueurs[str(self.myLogginName)]['Entrees statistiques tournois']["Argent "+str(self.entreeMainsArgent)][entree]["Compteur"]]
				tupple+=[(Entree[stack],ROIMoy[stack],NbrTournois[stack])]
				stack+=1
			tupple.sort(lambda a,b:cmp(a[0],b[0]))
			Entree=[]
			ROIMoy=[]
			NbrTournois=[]
			for entree in tupple:
				Entree+=[str(entree[0])]
				if not str(entree[1])=="-":
					ROIMoy+=[float(entree[1])]
				else:
					ROIMoy+=[0]
				NbrTournois+=[float(entree[2])]
			az=fig.add_subplot(224)
			width=0.35#the width of the bars
			p1=az.bar(ind2, ROIMoy, width, color='g', bottom=0)
			az.set_xticks(ind)
			az.set_xticklabels(Entree)
			az.set_title("Evolution du ROI moyen en fonction de l'entree \nen argent "+str(self.entreeMainsArgent)+" pour le joueur "+str(self.myLogginName),fontsize=10)
			az.grid(True)
#			ay=fig.add_subplot(224)
#			width=0.5#the width of the bars
#			p1=ay.bar(ind2, NbrTournois, width, color='r', bottom=0)
#			ay.set_xticks(ind)
#			ay.set_xticklabels(Entree)
#			ay.set_title("Evolution du nombre de tournois en fonction de l'entree \nen argent "+str(self.entreeMainsArgent)+" pour le joueur "+str(self.myLogginName),fontsize=10)
#			ay.grid(True)
			pylab.show()
		except:
			self.interface.config(state='normal')
			self.interface.insert("end","Vous devez télécharger les bibliothèques numpy et matplotlib")
			self.interface.config(state='disable')

	def calculette(self):
		"""Calculette pratique"""
		calculetteWindows=Tkinter.Toplevel()
		frame=Tkinter.Frame(calculetteWindows,width=30)
		frame.pack()
		self.entreeCalculette=Tkinter.Entry(frame,width=30)
		self.entreeCalculette.grid(row=0,column=0,columnspan=2)
		button1=Tkinter.Button(frame,command=self.showRes,text="Calculer")
		button1.grid(row=1,column=0)
		button2=Tkinter.Button(frame,command=self.showTime,text="Conversion minutes/heure+minutes")
		button2.grid(row=1,column=1)
		button3=Tkinter.Button(frame,command=calculetteWindows.destroy,text="Annuler")
		button3.grid(row=1,column=2)

	def showRes(self):
		"""Calculette pratique"""
		string="sol="+str(self.entreeCalculette.get())
		if len(string)<=100:
			try:
				exec string
			except:
				sol="Rentrer une formule valide"
		else:
			sol="La formule ne doit pas excéder 100 caractères"
		self.entreeCalculette.delete(0,'end')
		self.entreeCalculette.insert('0',str(sol))

	def showTime(self):
		"""Calculette pratique : Calculte le temps heure+minute en fonction du nombre de minutes"""
		entree=self.entreeCalculette.get()
		if len(entree)<=100:
			try:
				minutes=int(entree)
				heures=int(minutes/60)
				minutes2=minutes-heures*60
				string=str(heures)+":"+str(minutes2)
			except:
				sol="Rentrer une formule valide"
		else:
			sol="La formule ne doit pas excéder 100 caractères"
		self.entreeCalculette.delete(0,'end')
		self.entreeCalculette.insert('0',str(string))

root=Tkinter.Tk()
myapp=PyTracker(root)
root.mainloop()

Conclusion :


N'hésitez pas a me solliciter pour faire évoluer ce programme !!!

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.