From 95f43dfd7430a9cd0fecd878631e2eb990b8182a Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Sat, 6 Dec 2008 14:13:38 +0000
Subject: [PATCH 01/12] pot total and rake

---
 pyfpdb/EverleafToFpdb.py       |  11 ++--
 pyfpdb/HandHistoryConverter.py | 110 ++++++++++++++++++++-------------
 2 files changed, 72 insertions(+), 49 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 51d78451..7d1ce140 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -58,6 +58,9 @@ from HandHistoryConverter import *
 # smaragdar calls [$ 34.50 USD]
 # ** Dealing Turn ** [ 2d ]
 # ** Dealing River ** [ 6c ]
+# dogge shows [ 9h, 9c ]a pair of nines
+# spicybum shows [ 5d, 6d ]a straight, eight high
+# harrydebeng does not show cards
 # smaragdar wins $ 102 USD from main pot with a pair of aces [ ad, ah, qs, 8h, 6c ]
 
 class Everleaf(HandHistoryConverter):
@@ -116,9 +119,7 @@ class Everleaf(HandHistoryConverter):
 
 		for a in m:
 			hand.addPlayer(a.group('SEAT'), a.group('PNAME'), a.group('CASH'))
-			#players = players + [[a.group('SEAT'), a.group('PNAME'), a.group('CASH')]]
 
-		#hand.players = players
 
 	def markStreets(self, hand):
 		# PREFLOP = ** Dealing down cards **
@@ -159,14 +160,14 @@ class Everleaf(HandHistoryConverter):
 				hand.addCall( street, action.group('PNAME'), action.group('BET') )
 			elif action.group('ATYPE') == 'bets':
 				hand.addBet( street, action.group('PNAME'), action.group('BET') )
-			# mct: do we need to keep bet distinct from raise?
-			#	hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE'), action.group('BET')]]
 			else:
 				print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
 				hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
-		#print "DEBUG: readAction: %s " %(hand.actions)
 
 
+	def getRake(self, hand):
+		hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right
+
 if __name__ == "__main__":
 	c = Configuration.Config()
 	e = Everleaf(c, "Speed_Kuala.txt")
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index dd515da2..db93f6e5 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -74,13 +74,20 @@ class HandHistoryConverter:
 			for street in hand.streets.groupdict():
 				self.readAction(hand, street)
 
+			# finalise it (total the pot)
+			hand.totalPot()
+			self.getRake(hand)
+			
 			if(hand.involved == True):
 				#self.writeHand("output file", hand)
 				hand.printHand()
 			else:
 				pass #Don't write out observed hands
 
-	# Functions to be implemented in the inheriting class
+	#####
+	# These functions are parse actions that may be overridden by the inheriting class
+	#
+	
 	def readSupportedGames(self): abstract
 
 	# should return a list
@@ -89,7 +96,14 @@ class HandHistoryConverter:
 	# Valid types specified in docs/tabledesign.html in Gametypes
 	def determineGameType(self): abstract
 
-	#TODO: Comment
+	# Read any of:
+	# HID		HandID
+	# TABLE		Table name
+	# SB 		small blind
+	# BB		big blind
+	# GAMETYPE	gametype
+	# YEAR MON DAY HR MIN SEC 	datetime
+	# BUTTON	button seat number
 	def readHandInfo(self, hand): abstract
 
 	# Needs to return a list of lists in the format
@@ -97,6 +111,7 @@ class HandHistoryConverter:
 	def readPlayerStacks(self, hand): abstract
 
 	# Needs to return a MatchObject with group names identifying the streets into the Hand object
+	# that is, pulls the chunks of preflop, flop, turn and river text into hand.streets MatchObject.
 	def markStreets(self, hand): abstract
 
 	#Needs to return a list in the format
@@ -105,7 +120,11 @@ class HandHistoryConverter:
 	def readBlinds(self, hand): abstract
 	def readHeroCards(self, hand): abstract
 	def readAction(self, hand, street): abstract
-
+	
+	# Some sites don't report the rake. This will be called at the end of the hand after the pot total has been calculated
+	# so that an inheriting class can calculate it for the specific site if need be.
+	def getRake(self, hand): abstract
+	
 	def sanityCheck(self):
 		sane = True
 		base_w = False
@@ -265,12 +284,11 @@ class Hand:
 		self.hero = "Hiro"
 		self.holecards = "Xx Xx"
 		self.action = []
-		
-		self.rake = 0
+		self.totalpot = None
+		self.rake = None
 		
 		self.bets = {}
 		self.lastBet = {}
-		self.orderedBets = {}
 		for street in self.STREETS:
 			self.bets[street] = {}
 			self.lastBet[street] = 0
@@ -285,7 +303,7 @@ class Hand:
 		#self.endChips[name] = chips
 		#self.winners[name] = 0
 		for street in self.STREETS:
-			self.bets[street][name] = [0]
+			self.bets[street][name] = []
 
 
 	def addHoleCards(self,h1,h2,seat=None): # generalise to add hole cards for a specific seat or player
@@ -300,36 +318,53 @@ class Hand:
 		return c
 
 	def addBlind(self, player, amount):
-		#self.bets['BLINDS'][player].append(Decimal(amount))
+		# if player is None, it's a missing small blind.
+		if player is not None:
+			self.bets['PREFLOP'][player].append(Decimal(amount))
 		self.lastBet['PREFLOP'] = Decimal(amount)
 		self.posted += [player]
 		
 
-	def addCall(self, street, player=None, amount=0):
-		self.bets[street][player].append(Decimal(amount))
-		#self.lastBet[street] = Decimal(amount)
-		self.actions[street] += [[player, 'calls', amount]]
+	def addCall(self, street, player=None, amount=None):
+		# Potentially calculate the amount of the call if not supplied
+		# corner cases include if player would be all in
+		if amount is not None:
+			self.bets[street][player].append(Decimal(amount))
+			#self.lastBet[street] = Decimal(amount)
+			self.actions[street] += [[player, 'calls', amount]]
 		
 	def addRaiseTo(self, street, player, amountTo):
-		# amount is the amount raised to, not the amount raised.by
+		# Given only the amount raised to, the amount of the raise can be calculated by
+		# working out how much this player has already in the pot 
+		#   (which is the sum of self.bets[street][player])
+		# and how much he needs to call to match the previous player 
+		#   (which is tracked by self.lastBet)
 		committedThisStreet = reduce(operator.add, self.bets[street][player], 0)
 		amountToCall = self.lastBet[street] - committedThisStreet
 		self.lastBet[street] = Decimal(amountTo)
 		amountBy = Decimal(amountTo) - amountToCall
-		self.bets[street][player].append(amountBy)
+		self.bets[street][player].append(amountBy+amountToCall)
 		self.actions[street] += [[player, 'raises', amountBy, amountTo]]
-	
-	#def addRaiseTo(self, street, player=None, amountTo=None):
-		#self.amounts[street] += Decimal(amountTo)
-		
 		
 	def addBet(self, street, player=None, amount=0):
 		self.bets[street][name].append(Decimal(amount))
 		self.orderedBets[street].append(Decimal(amount))
 		self.actions[street] += [[player, 'bets', amount]]
 		
-	
-	
+	def totalPot(self):
+		
+		if self.totalpot is None:
+			self.totalpot = 0
+			
+			# player names: 
+			# print [x[1] for x in self.players]
+			for player in [x[1] for x in self.players]:
+				for street in self.STREETS:
+					print street, self.bets[street][player]
+					self.totalpot += reduce(operator.add, self.bets[street][player], 0)
+					
+
+
 	def printHand(self):
 		# PokerStars format.
 		print "### DEBUG ###"
@@ -370,31 +405,18 @@ class Hand:
 			print "*** RIVER *** [%s %s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
 			for act in self.actions['RIVER']:
 				self.printActionLine(act)
-
-		print "*** SUMMARY ***"
-		print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
-#		print "Total pot $%s | Rake $%s)" %(hand.totalpot  $" + hand.rake)
-#		print "Board [" + boardcards + "]"
-#
-#		SUMMARY STUFF
-
+				
+				
+		#Some sites don't have a showdown section so we have to figure out if there should be one
+		# The logic for a showdown is: at the end of river action there are at least two players in the hand
+		if 'SHOWDOWN' in self.actions:
+			print "*** SHOW DOWN ***"
+			print "what do they show"
 		
-		#print self.sitename
-		#print self.gametype
-		#print self.string
-		#print self.handid
-		#print self.sb
-		#print self.bb
-		#print self.tablename
-		#print self.maxseats
-		#print self.counted_seats
-		#print self.buttonpos
-		#print self.seating
-		#print self.players
-		#print self.posted
-		#print self.action
-		#print self.involved
-		#print self.hero
+		print "*** SUMMARY ***"
+		print "Total pot $%s | Rake $%s)" % (self.totalpot, self.rake)
+		print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+
 
 	def printActionLine(self, act):
 		if act[1] == 'folds' or act[1] == 'checks':

From 72addde5103037e876d7c09aa928b00f4a9e21eb Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Sat, 6 Dec 2008 14:15:41 +0000
Subject: [PATCH 02/12] whitespace

---
 pyfpdb/EverleafToFpdb.py       | 162 ++++----
 pyfpdb/HandHistoryConverter.py | 660 ++++++++++++++++-----------------
 2 files changed, 411 insertions(+), 411 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 7d1ce140..d60211b6 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -64,39 +64,39 @@ from HandHistoryConverter import *
 # smaragdar wins $ 102 USD from main pot with a pair of aces [ ad, ah, qs, 8h, 6c ]
 
 class Everleaf(HandHistoryConverter):
-	def __init__(self, config, file):
-		print "Initialising Everleaf converter class"
-		HandHistoryConverter.__init__(self, config, file, "Everleaf") # Call super class init.
-		self.sitename = "Everleaf"
-		self.setFileType("text")
-		self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
-		self.rexx.setSplitHandRegex('\n\n\n\n')
-		self.rexx.setHandInfoRegex('.*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<YEAR>[0-9]+)/(?P<MON>[0-9]+)/(?P<DAY>[0-9]+) - (?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)\nTable (?P<TABLE>[ a-zA-Z]+)\nSeat (?P<BUTTON>[0-9]+)')
-		self.rexx.setPlayerInfoRegex('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(  \$ (?P<CASH>[.0-9]+) USD \)')
-		self.rexx.setPostSbRegex('.*\n(?P<PNAME>.*): posts small blind \[\$? (?P<SB>[.0-9]+)')
-		self.rexx.setPostBbRegex('.*\n(?P<PNAME>.*): posts big blind \[\$? (?P<BB>[.0-9]+)')
-		# mct : what about posting small & big blinds simultaneously?
-		self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLE1>\S\S), (?P<HOLE2>\S\S) \]')
-		self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*) (?P<ATYPE>bets|checks|raises|calls|folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
-		self.rexx.compileRegexes()
+    def __init__(self, config, file):
+        print "Initialising Everleaf converter class"
+        HandHistoryConverter.__init__(self, config, file, "Everleaf") # Call super class init.
+        self.sitename = "Everleaf"
+        self.setFileType("text")
+        self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
+        self.rexx.setSplitHandRegex('\n\n\n\n')
+        self.rexx.setHandInfoRegex('.*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<YEAR>[0-9]+)/(?P<MON>[0-9]+)/(?P<DAY>[0-9]+) - (?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)\nTable (?P<TABLE>[ a-zA-Z]+)\nSeat (?P<BUTTON>[0-9]+)')
+        self.rexx.setPlayerInfoRegex('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(  \$ (?P<CASH>[.0-9]+) USD \)')
+        self.rexx.setPostSbRegex('.*\n(?P<PNAME>.*): posts small blind \[\$? (?P<SB>[.0-9]+)')
+        self.rexx.setPostBbRegex('.*\n(?P<PNAME>.*): posts big blind \[\$? (?P<BB>[.0-9]+)')
+        # mct : what about posting small & big blinds simultaneously?
+        self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLE1>\S\S), (?P<HOLE2>\S\S) \]')
+        self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*) (?P<ATYPE>bets|checks|raises|calls|folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
+        self.rexx.compileRegexes()
 
-	def readSupportedGames(self):
-		pass
+    def readSupportedGames(self):
+        pass
 
-	def determineGameType(self):
-		# Cheating with this regex, only support nlhe at the moment
-		gametype = ["ring", "hold", "nl"]
+    def determineGameType(self):
+        # Cheating with this regex, only support nlhe at the moment
+        gametype = ["ring", "hold", "nl"]
 
-		m = self.rexx.game_info_re.search(self.obs)
-		gametype = gametype + [m.group('SB')]
-		gametype = gametype + [m.group('BB')]
-		
-		return gametype
+        m = self.rexx.game_info_re.search(self.obs)
+        gametype = gametype + [m.group('SB')]
+        gametype = gametype + [m.group('BB')]
+        
+        return gametype
 
-	def readHandInfo(self, hand):
-		m =  self.rexx.hand_info_re.search(hand.string)
-		hand.handid = m.group('HID')
-		hand.tablename = m.group('TABLE')
+    def readHandInfo(self, hand):
+        m =  self.rexx.hand_info_re.search(hand.string)
+        hand.handid = m.group('HID')
+        hand.tablename = m.group('TABLE')
 # These work, but the info is already in the Hand class - should be used for tourneys though.
 #		m.group('SB')
 #		m.group('BB')
@@ -109,68 +109,68 @@ class Everleaf(HandHistoryConverter):
 # 2008/11/10 3:58:52 ET
 #TODO: Do conversion from GMT to ET
 #TODO: Need some date functions to convert to different timezones (Date::Manip for perl rocked for this)
-		hand.starttime = "%d/%02d/%02d %d:%02d:%02d ET" %(int(m.group('YEAR')), int(m.group('MON')), int(m.group('DAY')),
-							  int(m.group('HR')), int(m.group('MIN')), int(m.group('SEC')))
-		hand.buttonpos = int(m.group('BUTTON'))
+        hand.starttime = "%d/%02d/%02d %d:%02d:%02d ET" %(int(m.group('YEAR')), int(m.group('MON')), int(m.group('DAY')),
+                            int(m.group('HR')), int(m.group('MIN')), int(m.group('SEC')))
+        hand.buttonpos = int(m.group('BUTTON'))
 
-	def readPlayerStacks(self, hand):
-		m = self.rexx.player_info_re.finditer(hand.string)
-		players = []
+    def readPlayerStacks(self, hand):
+        m = self.rexx.player_info_re.finditer(hand.string)
+        players = []
 
-		for a in m:
-			hand.addPlayer(a.group('SEAT'), a.group('PNAME'), a.group('CASH'))
+        for a in m:
+            hand.addPlayer(a.group('SEAT'), a.group('PNAME'), a.group('CASH'))
 
 
-	def markStreets(self, hand):
-		# PREFLOP = ** Dealing down cards **
-		m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
+    def markStreets(self, hand):
+        # PREFLOP = ** Dealing down cards **
+        m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
 #		for street in m.groupdict():
 #			print "DEBUG: Street: %s\tspan: %s" %(street, str(m.span(street)))
-		hand.streets = m
+        hand.streets = m
 
-	def readBlinds(self, hand):
-		try:
-			m = self.rexx.small_blind_re.search(hand.string)
-			hand.addBlind(m.group('PNAME'), m.group('SB'))
-			#hand.posted = [m.group('PNAME')]
-		except:
-			hand.addBlind(None, 0)
-			#hand.posted = ["FpdbNBP"]
-		m = self.rexx.big_blind_re.finditer(hand.string)
-		for a in m:
-			hand.addBlind(a.group('PNAME'), a.group('BB'))
-			#hand.posted = hand.posted + [a.group('PNAME')]
+    def readBlinds(self, hand):
+        try:
+            m = self.rexx.small_blind_re.search(hand.string)
+            hand.addBlind(m.group('PNAME'), m.group('SB'))
+            #hand.posted = [m.group('PNAME')]
+        except:
+            hand.addBlind(None, 0)
+            #hand.posted = ["FpdbNBP"]
+        m = self.rexx.big_blind_re.finditer(hand.string)
+        for a in m:
+            hand.addBlind(a.group('PNAME'), a.group('BB'))
+            #hand.posted = hand.posted + [a.group('PNAME')]
 
-	def readHeroCards(self, hand):
-		m = self.rexx.hero_cards_re.search(hand.string)
-		if(m == None):
-			#Not involved in hand
-			hand.involved = False
-		else:
-			hand.hero = m.group('PNAME')
-			hand.addHoleCards(m.group('HOLE1'), m.group('HOLE2'))
+    def readHeroCards(self, hand):
+        m = self.rexx.hero_cards_re.search(hand.string)
+        if(m == None):
+            #Not involved in hand
+            hand.involved = False
+        else:
+            hand.hero = m.group('PNAME')
+            hand.addHoleCards(m.group('HOLE1'), m.group('HOLE2'))
 
-	def readAction(self, hand, street):
-		m = self.rexx.action_re.finditer(hand.streets.group(street))
-		hand.actions[street] = []
-		for action in m:
-			if action.group('ATYPE') == 'raises':
-				hand.addRaiseTo( street, action.group('PNAME'), action.group('BET') )
-			elif action.group('ATYPE') == 'calls':
-				hand.addCall( street, action.group('PNAME'), action.group('BET') )
-			elif action.group('ATYPE') == 'bets':
-				hand.addBet( street, action.group('PNAME'), action.group('BET') )
-			else:
-				print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
-				hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
+    def readAction(self, hand, street):
+        m = self.rexx.action_re.finditer(hand.streets.group(street))
+        hand.actions[street] = []
+        for action in m:
+            if action.group('ATYPE') == 'raises':
+                hand.addRaiseTo( street, action.group('PNAME'), action.group('BET') )
+            elif action.group('ATYPE') == 'calls':
+                hand.addCall( street, action.group('PNAME'), action.group('BET') )
+            elif action.group('ATYPE') == 'bets':
+                hand.addBet( street, action.group('PNAME'), action.group('BET') )
+            else:
+                print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
+                hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
 
 
-	def getRake(self, hand):
-		hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right
+    def getRake(self, hand):
+        hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right
 
 if __name__ == "__main__":
-	c = Configuration.Config()
-	e = Everleaf(c, "Speed_Kuala.txt")
-	e.processFile()
-	print str(e)
-	
+    c = Configuration.Config()
+    e = Everleaf(c, "Speed_Kuala.txt")
+    e.processFile()
+    print str(e)
+    
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index db93f6e5..71bc0b25 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -28,400 +28,400 @@ import operator
 from xml.dom.minidom import Node
 
 class HandHistoryConverter:
-	def __init__(self, config, file, sitename):
-		print "HandHistory init called"
-		self.c         = config
-		self.sitename  = sitename
-		self.obs       = ""             # One big string
-		self.filetype  = "text"
-		self.doc       = None     # For XML based HH files
-		self.file      = file
-		self.hhbase    = self.c.get_import_parameters().get("hhArchiveBase")
-		self.hhbase    = os.path.expanduser(self.hhbase)
-		self.hhdir     = os.path.join(self.hhbase,sitename)
-		self.gametype  = []
+    def __init__(self, config, file, sitename):
+        print "HandHistory init called"
+        self.c         = config
+        self.sitename  = sitename
+        self.obs       = ""             # One big string
+        self.filetype  = "text"
+        self.doc       = None     # For XML based HH files
+        self.file      = file
+        self.hhbase    = self.c.get_import_parameters().get("hhArchiveBase")
+        self.hhbase    = os.path.expanduser(self.hhbase)
+        self.hhdir     = os.path.join(self.hhbase,sitename)
+        self.gametype  = []
 #		self.ofile     = os.path.join(self.hhdir,file)
-		self.rexx      = FpdbRegex.FpdbRegex()
+        self.rexx      = FpdbRegex.FpdbRegex()
 
-	def __str__(self):
-		tmp = "HandHistoryConverter: '%s'\n" % (self.sitename)
-		tmp = tmp + "\thhbase:     '%s'\n" % (self.hhbase)
-		tmp = tmp + "\thhdir:      '%s'\n" % (self.hhdir)
-		tmp = tmp + "\tfiletype:   '%s'\n" % (self.filetype)
-		tmp = tmp + "\tinfile:     '%s'\n" % (self.file)
+    def __str__(self):
+        tmp = "HandHistoryConverter: '%s'\n" % (self.sitename)
+        tmp = tmp + "\thhbase:     '%s'\n" % (self.hhbase)
+        tmp = tmp + "\thhdir:      '%s'\n" % (self.hhdir)
+        tmp = tmp + "\tfiletype:   '%s'\n" % (self.filetype)
+        tmp = tmp + "\tinfile:     '%s'\n" % (self.file)
 #		tmp = tmp + "\toutfile:    '%s'\n" % (self.ofile)
 #		tmp = tmp + "\tgametype:   '%s'\n" % (self.gametype[0])
 #		tmp = tmp + "\tgamebase:   '%s'\n" % (self.gametype[1])
 #		tmp = tmp + "\tlimit:      '%s'\n" % (self.gametype[2])
 #		tmp = tmp + "\tsb/bb:      '%s/%s'\n" % (self.gametype[3], self.gametype[4])
-		return tmp
+        return tmp
 
-	def processFile(self):
-		if not self.sanityCheck():
-			print "Cowardly refusing to continue after failed sanity check"
-			return
-		self.readFile(self.file)
-		self.gametype = self.determineGameType()
-		self.hands = self.splitFileIntoHands()
-		for hand in self.hands:
-			self.readHandInfo(hand)
-			self.readPlayerStacks(hand)
-			self.markStreets(hand)
-			self.readBlinds(hand)
-			self.readHeroCards(hand)
+    def processFile(self):
+        if not self.sanityCheck():
+            print "Cowardly refusing to continue after failed sanity check"
+            return
+        self.readFile(self.file)
+        self.gametype = self.determineGameType()
+        self.hands = self.splitFileIntoHands()
+        for hand in self.hands:
+            self.readHandInfo(hand)
+            self.readPlayerStacks(hand)
+            self.markStreets(hand)
+            self.readBlinds(hand)
+            self.readHeroCards(hand)
 
-			# Read action (Note: no guarantee this is in hand order.
-			for street in hand.streets.groupdict():
-				self.readAction(hand, street)
+            # Read action (Note: no guarantee this is in hand order.
+            for street in hand.streets.groupdict():
+                self.readAction(hand, street)
 
-			# finalise it (total the pot)
-			hand.totalPot()
-			self.getRake(hand)
-			
-			if(hand.involved == True):
-				#self.writeHand("output file", hand)
-				hand.printHand()
-			else:
-				pass #Don't write out observed hands
+            # finalise it (total the pot)
+            hand.totalPot()
+            self.getRake(hand)
+            
+            if(hand.involved == True):
+                #self.writeHand("output file", hand)
+                hand.printHand()
+            else:
+                pass #Don't write out observed hands
 
-	#####
-	# These functions are parse actions that may be overridden by the inheriting class
-	#
-	
-	def readSupportedGames(self): abstract
+    #####
+    # These functions are parse actions that may be overridden by the inheriting class
+    #
+    
+    def readSupportedGames(self): abstract
 
-	# should return a list
-	#   type  base limit
-	# [ ring, hold, nl   , sb, bb ]
-	# Valid types specified in docs/tabledesign.html in Gametypes
-	def determineGameType(self): abstract
+    # should return a list
+    #   type  base limit
+    # [ ring, hold, nl   , sb, bb ]
+    # Valid types specified in docs/tabledesign.html in Gametypes
+    def determineGameType(self): abstract
 
-	# Read any of:
-	# HID		HandID
-	# TABLE		Table name
-	# SB 		small blind
-	# BB		big blind
-	# GAMETYPE	gametype
-	# YEAR MON DAY HR MIN SEC 	datetime
-	# BUTTON	button seat number
-	def readHandInfo(self, hand): abstract
+    # Read any of:
+    # HID		HandID
+    # TABLE		Table name
+    # SB 		small blind
+    # BB		big blind
+    # GAMETYPE	gametype
+    # YEAR MON DAY HR MIN SEC 	datetime
+    # BUTTON	button seat number
+    def readHandInfo(self, hand): abstract
 
-	# Needs to return a list of lists in the format
-	# [['seat#', 'player1name', 'stacksize'] ['seat#', 'player2name', 'stacksize'] [...]]
-	def readPlayerStacks(self, hand): abstract
+    # Needs to return a list of lists in the format
+    # [['seat#', 'player1name', 'stacksize'] ['seat#', 'player2name', 'stacksize'] [...]]
+    def readPlayerStacks(self, hand): abstract
 
-	# Needs to return a MatchObject with group names identifying the streets into the Hand object
-	# that is, pulls the chunks of preflop, flop, turn and river text into hand.streets MatchObject.
-	def markStreets(self, hand): abstract
+    # Needs to return a MatchObject with group names identifying the streets into the Hand object
+    # that is, pulls the chunks of preflop, flop, turn and river text into hand.streets MatchObject.
+    def markStreets(self, hand): abstract
 
-	#Needs to return a list in the format
-	# ['player1name', 'player2name', ...] where player1name is the sb and player2name is bb, 
-	# addtional players are assumed to post a bb oop
-	def readBlinds(self, hand): abstract
-	def readHeroCards(self, hand): abstract
-	def readAction(self, hand, street): abstract
-	
-	# Some sites don't report the rake. This will be called at the end of the hand after the pot total has been calculated
-	# so that an inheriting class can calculate it for the specific site if need be.
-	def getRake(self, hand): abstract
-	
-	def sanityCheck(self):
-		sane = True
-		base_w = False
-		#Check if hhbase exists and is writable
-		#Note: Will not try to create the base HH directory
-		if not (os.access(self.hhbase, os.W_OK) and os.path.isdir(self.hhbase)):
-			print "HH Sanity Check: Directory hhbase '" + self.hhbase + "' doesn't exist or is not writable"
-		else:
-			#Check if hhdir exists and is writable
-			if not os.path.isdir(self.hhdir):
-				# In first pass, dir may not exist. Attempt to create dir
-				print "Creating directory: '%s'" % (self.hhdir)
-				os.mkdir(self.hhdir)
-				sane = True
-			elif os.access(self.hhdir, os.W_OK):
-				sane = True
-			else:
-				print "HH Sanity Check: Directory hhdir '" + self.hhdir + "' or its parent directory are not writable"
+    #Needs to return a list in the format
+    # ['player1name', 'player2name', ...] where player1name is the sb and player2name is bb, 
+    # addtional players are assumed to post a bb oop
+    def readBlinds(self, hand): abstract
+    def readHeroCards(self, hand): abstract
+    def readAction(self, hand, street): abstract
+    
+    # Some sites don't report the rake. This will be called at the end of the hand after the pot total has been calculated
+    # so that an inheriting class can calculate it for the specific site if need be.
+    def getRake(self, hand): abstract
+    
+    def sanityCheck(self):
+        sane = True
+        base_w = False
+        #Check if hhbase exists and is writable
+        #Note: Will not try to create the base HH directory
+        if not (os.access(self.hhbase, os.W_OK) and os.path.isdir(self.hhbase)):
+            print "HH Sanity Check: Directory hhbase '" + self.hhbase + "' doesn't exist or is not writable"
+        else:
+            #Check if hhdir exists and is writable
+            if not os.path.isdir(self.hhdir):
+                # In first pass, dir may not exist. Attempt to create dir
+                print "Creating directory: '%s'" % (self.hhdir)
+                os.mkdir(self.hhdir)
+                sane = True
+            elif os.access(self.hhdir, os.W_OK):
+                sane = True
+            else:
+                print "HH Sanity Check: Directory hhdir '" + self.hhdir + "' or its parent directory are not writable"
 
-		return sane
+        return sane
 
-	# Functions not necessary to implement in sub class
-	def setFileType(self, filetype = "text"):
-		self.filetype = filetype
+    # Functions not necessary to implement in sub class
+    def setFileType(self, filetype = "text"):
+        self.filetype = filetype
 
-	def splitFileIntoHands(self):
-		hands = []
-		list = self.rexx.split_hand_re.split(self.obs)
-		list.pop() #Last entry is empty
-		for l in list:
+    def splitFileIntoHands(self):
+        hands = []
+        list = self.rexx.split_hand_re.split(self.obs)
+        list.pop() #Last entry is empty
+        for l in list:
 #			print "'" + l + "'"
-			hands = hands + [Hand(self.sitename, self.gametype, l)]
-		return hands
+            hands = hands + [Hand(self.sitename, self.gametype, l)]
+        return hands
 
-	def readFile(self, filename):
-		"""Read file"""
-		print "Reading file: '%s'" %(filename)
-		if(self.filetype == "text"):
-			infile=open(filename, "rU")
-			self.obs = infile.read()
-			infile.close()
-		elif(self.filetype == "xml"):
-			try:
-				doc = xml.dom.minidom.parse(filename)
-				self.doc = doc
-			except:
-				traceback.print_exc(file=sys.stderr)
+    def readFile(self, filename):
+        """Read file"""
+        print "Reading file: '%s'" %(filename)
+        if(self.filetype == "text"):
+            infile=open(filename, "rU")
+            self.obs = infile.read()
+            infile.close()
+        elif(self.filetype == "xml"):
+            try:
+                doc = xml.dom.minidom.parse(filename)
+                self.doc = doc
+            except:
+                traceback.print_exc(file=sys.stderr)
 
-	def writeHand(self, file, hand):
-		"""Write out parsed data"""
-		print "DEBUG: *************************"
-		print "DEBUG: Start of print hand"
-		print "DEBUG: *************************"
+    def writeHand(self, file, hand):
+        """Write out parsed data"""
+        print "DEBUG: *************************"
+        print "DEBUG: Start of print hand"
+        print "DEBUG: *************************"
 
-		print "%s Game #%s: %s ($%s/$%s) - %s" %(hand.sitename, hand.handid, "XXXXhand.gametype", hand.sb, hand.bb, hand.starttime)
-		print "Table '%s' %d-max Seat #%s is the button" %(hand.tablename, hand.maxseats, hand.buttonpos)
+        print "%s Game #%s: %s ($%s/$%s) - %s" %(hand.sitename, hand.handid, "XXXXhand.gametype", hand.sb, hand.bb, hand.starttime)
+        print "Table '%s' %d-max Seat #%s is the button" %(hand.tablename, hand.maxseats, hand.buttonpos)
 
-		for player in hand.players:
-			print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
+        for player in hand.players:
+            print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
 
-		if(hand.posted[0] == "FpdbNBP"):
-			print "No small blind posted"
-		else:
-			print "%s: posts small blind $%s" %(hand.posted[0], hand.sb)
+        if(hand.posted[0] == "FpdbNBP"):
+            print "No small blind posted"
+        else:
+            print "%s: posts small blind $%s" %(hand.posted[0], hand.sb)
 
-		#May be more than 1 bb posting
-		print "%s: posts big blind $%s" %(hand.posted[1], hand.bb)
-		if(len(hand.posted) > 2):
-			# Need to loop on all remaining big blinds - lazy
-			print "XXXXXXXXX FIXME XXXXXXXX"
+        #May be more than 1 bb posting
+        print "%s: posts big blind $%s" %(hand.posted[1], hand.bb)
+        if(len(hand.posted) > 2):
+            # Need to loop on all remaining big blinds - lazy
+            print "XXXXXXXXX FIXME XXXXXXXX"
 
-		print "*** HOLE CARDS ***"
-		print "Dealt to %s [%s %s]" %(hand.hero , hand.holecards[0], hand.holecards[1])
+        print "*** HOLE CARDS ***"
+        print "Dealt to %s [%s %s]" %(hand.hero , hand.holecards[0], hand.holecards[1])
 #
 ##		ACTION STUFF
 #		This is no limit only at the moment
-		
-		for act in hand.actions['PREFLOP']:
-			self.printActionLine(act, 0)
+        
+        for act in hand.actions['PREFLOP']:
+            self.printActionLine(act, 0)
 
-		if 'PREFLOP' in hand.actions:
-			for act in hand.actions['PREFLOP']:
-				print "PF action"
+        if 'PREFLOP' in hand.actions:
+            for act in hand.actions['PREFLOP']:
+                print "PF action"
 
-		if 'FLOP' in hand.actions:
-			print "*** FLOP *** [%s %s %s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"))
-			for act in hand.actions['FLOP']:
-				self.printActionLine(act, 0)
+        if 'FLOP' in hand.actions:
+            print "*** FLOP *** [%s %s %s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"))
+            for act in hand.actions['FLOP']:
+                self.printActionLine(act, 0)
 
-		if 'TURN' in hand.actions:
-			print "*** TURN *** [%s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"))
-			for act in hand.actions['TURN']:
-				self.printActionLine(act, 0)
+        if 'TURN' in hand.actions:
+            print "*** TURN *** [%s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"))
+            for act in hand.actions['TURN']:
+                self.printActionLine(act, 0)
 
-		if 'RIVER' in hand.actions:
-			print "*** RIVER *** [%s %s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"), hand.streets.group("RIVER1"))
-			for act in hand.actions['RIVER']:
-				self.printActionLine(act, 0)
+        if 'RIVER' in hand.actions:
+            print "*** RIVER *** [%s %s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"), hand.streets.group("RIVER1"))
+            for act in hand.actions['RIVER']:
+                self.printActionLine(act, 0)
 
-		print "*** SUMMARY ***"
-		print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
+        print "*** SUMMARY ***"
+        print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
 #		print "Total pot $%s | Rake $%s)" %(hand.totalpot  $" + hand.rake)
 #		print "Board [" + boardcards + "]"
 #
 #		SUMMARY STUFF
 
 
-	def printActionLine(self, act, pot):
-		if act[1] == 'folds' or act[1] == 'checks':
-			print "%s: %s " %(act[0], act[1])
-		if act[1] == 'calls':
-			print "%s: %s $%s" %(act[0], act[1], act[2])
-		if act[1] == 'raises':
-			print "%s: %s $%s to XXXpottotalXXX" %(act[0], act[1], act[2])
-			
+    def printActionLine(self, act, pot):
+        if act[1] == 'folds' or act[1] == 'checks':
+            print "%s: %s " %(act[0], act[1])
+        if act[1] == 'calls':
+            print "%s: %s $%s" %(act[0], act[1], act[2])
+        if act[1] == 'raises':
+            print "%s: %s $%s to XXXpottotalXXX" %(act[0], act[1], act[2])
+            
 
 #takes a poker float (including , for thousand seperator and converts it to an int
-	def float2int (self, string):
-		pos=string.find(",")
-		if (pos!=-1): #remove , the thousand seperator
-			string=string[0:pos]+string[pos+1:]
+    def float2int (self, string):
+        pos=string.find(",")
+        if (pos!=-1): #remove , the thousand seperator
+            string=string[0:pos]+string[pos+1:]
 
-		pos=string.find(".")
-		if (pos!=-1): #remove decimal point
-			string=string[0:pos]+string[pos+1:]
+        pos=string.find(".")
+        if (pos!=-1): #remove decimal point
+            string=string[0:pos]+string[pos+1:]
 
-		result = int(string)
-		if pos==-1: #no decimal point - was in full dollars - need to multiply with 100
-			result*=100
-		return result
+        result = int(string)
+        if pos==-1: #no decimal point - was in full dollars - need to multiply with 100
+            result*=100
+        return result
 #end def float2int
 
 class Hand:
 #    def __init__(self, sitename, gametype, sb, bb, string):
 
-	UPS = {'a':'A', 't':'T', 'j':'J', 'q':'Q', 'k':'K'}
-	STREETS = ['BLINDS','PREFLOP','FLOP','TURN','RIVER']
-	def __init__(self, sitename, gametype, string):
-		self.sitename = sitename
-		self.gametype = gametype
-		self.string = string
-	
-		self.streets = None # A MatchObject using a groupnames to identify streets.
-		self.actions = {}
-	
-		self.handid = 0
-		self.sb = gametype[3]
-		self.bb = gametype[4]
-		self.tablename = "Slartibartfast"
-		self.maxseats = 10
-		self.counted_seats = 0
-		self.buttonpos = 0
-		self.seating = []
-		self.players = []
-		self.posted = []
-		self.involved = True
-		self.hero = "Hiro"
-		self.holecards = "Xx Xx"
-		self.action = []
-		self.totalpot = None
-		self.rake = None
-		
-		self.bets = {}
-		self.lastBet = {}
-		for street in self.STREETS:
-			self.bets[street] = {}
-			self.lastBet[street] = 0
-			
-	def addPlayer(self, seat, name, chips):
-		"""seat, an int indicating the seat
-		name, the player name
-		chips, the chips the player has at the start of the hand"""
-		#self.players.append(name)
-		self.players.append([seat, name, chips])
-		#self.startChips[name] = chips
-		#self.endChips[name] = chips
-		#self.winners[name] = 0
-		for street in self.STREETS:
-			self.bets[street][name] = []
+    UPS = {'a':'A', 't':'T', 'j':'J', 'q':'Q', 'k':'K'}
+    STREETS = ['BLINDS','PREFLOP','FLOP','TURN','RIVER']
+    def __init__(self, sitename, gametype, string):
+        self.sitename = sitename
+        self.gametype = gametype
+        self.string = string
+    
+        self.streets = None # A MatchObject using a groupnames to identify streets.
+        self.actions = {}
+    
+        self.handid = 0
+        self.sb = gametype[3]
+        self.bb = gametype[4]
+        self.tablename = "Slartibartfast"
+        self.maxseats = 10
+        self.counted_seats = 0
+        self.buttonpos = 0
+        self.seating = []
+        self.players = []
+        self.posted = []
+        self.involved = True
+        self.hero = "Hiro"
+        self.holecards = "Xx Xx"
+        self.action = []
+        self.totalpot = None
+        self.rake = None
+        
+        self.bets = {}
+        self.lastBet = {}
+        for street in self.STREETS:
+            self.bets[street] = {}
+            self.lastBet[street] = 0
+            
+    def addPlayer(self, seat, name, chips):
+        """seat, an int indicating the seat
+        name, the player name
+        chips, the chips the player has at the start of the hand"""
+        #self.players.append(name)
+        self.players.append([seat, name, chips])
+        #self.startChips[name] = chips
+        #self.endChips[name] = chips
+        #self.winners[name] = 0
+        for street in self.STREETS:
+            self.bets[street][name] = []
 
 
-	def addHoleCards(self,h1,h2,seat=None): # generalise to add hole cards for a specific seat or player
-		self.holecards = [self.card(h1), self.card(h2)]
+    def addHoleCards(self,h1,h2,seat=None): # generalise to add hole cards for a specific seat or player
+        self.holecards = [self.card(h1), self.card(h2)]
 
 
-	def card(self,c):
-		"""upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""
-	# don't know how to make this 'static'
-		for k,v in self.UPS.items():
-			c = c.replace(k,v)
-		return c
+    def card(self,c):
+        """upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""
+    # don't know how to make this 'static'
+        for k,v in self.UPS.items():
+            c = c.replace(k,v)
+        return c
 
-	def addBlind(self, player, amount):
-		# if player is None, it's a missing small blind.
-		if player is not None:
-			self.bets['PREFLOP'][player].append(Decimal(amount))
-		self.lastBet['PREFLOP'] = Decimal(amount)
-		self.posted += [player]
-		
+    def addBlind(self, player, amount):
+        # if player is None, it's a missing small blind.
+        if player is not None:
+            self.bets['PREFLOP'][player].append(Decimal(amount))
+        self.lastBet['PREFLOP'] = Decimal(amount)
+        self.posted += [player]
+        
 
-	def addCall(self, street, player=None, amount=None):
-		# Potentially calculate the amount of the call if not supplied
-		# corner cases include if player would be all in
-		if amount is not None:
-			self.bets[street][player].append(Decimal(amount))
-			#self.lastBet[street] = Decimal(amount)
-			self.actions[street] += [[player, 'calls', amount]]
-		
-	def addRaiseTo(self, street, player, amountTo):
-		# Given only the amount raised to, the amount of the raise can be calculated by
-		# working out how much this player has already in the pot 
-		#   (which is the sum of self.bets[street][player])
-		# and how much he needs to call to match the previous player 
-		#   (which is tracked by self.lastBet)
-		committedThisStreet = reduce(operator.add, self.bets[street][player], 0)
-		amountToCall = self.lastBet[street] - committedThisStreet
-		self.lastBet[street] = Decimal(amountTo)
-		amountBy = Decimal(amountTo) - amountToCall
-		self.bets[street][player].append(amountBy+amountToCall)
-		self.actions[street] += [[player, 'raises', amountBy, amountTo]]
-		
-	def addBet(self, street, player=None, amount=0):
-		self.bets[street][name].append(Decimal(amount))
-		self.orderedBets[street].append(Decimal(amount))
-		self.actions[street] += [[player, 'bets', amount]]
-		
-	def totalPot(self):
-		
-		if self.totalpot is None:
-			self.totalpot = 0
-			
-			# player names: 
-			# print [x[1] for x in self.players]
-			for player in [x[1] for x in self.players]:
-				for street in self.STREETS:
-					print street, self.bets[street][player]
-					self.totalpot += reduce(operator.add, self.bets[street][player], 0)
-					
+    def addCall(self, street, player=None, amount=None):
+        # Potentially calculate the amount of the call if not supplied
+        # corner cases include if player would be all in
+        if amount is not None:
+            self.bets[street][player].append(Decimal(amount))
+            #self.lastBet[street] = Decimal(amount)
+            self.actions[street] += [[player, 'calls', amount]]
+        
+    def addRaiseTo(self, street, player, amountTo):
+        # Given only the amount raised to, the amount of the raise can be calculated by
+        # working out how much this player has already in the pot 
+        #   (which is the sum of self.bets[street][player])
+        # and how much he needs to call to match the previous player 
+        #   (which is tracked by self.lastBet)
+        committedThisStreet = reduce(operator.add, self.bets[street][player], 0)
+        amountToCall = self.lastBet[street] - committedThisStreet
+        self.lastBet[street] = Decimal(amountTo)
+        amountBy = Decimal(amountTo) - amountToCall
+        self.bets[street][player].append(amountBy+amountToCall)
+        self.actions[street] += [[player, 'raises', amountBy, amountTo]]
+        
+    def addBet(self, street, player=None, amount=0):
+        self.bets[street][name].append(Decimal(amount))
+        self.orderedBets[street].append(Decimal(amount))
+        self.actions[street] += [[player, 'bets', amount]]
+        
+    def totalPot(self):
+        
+        if self.totalpot is None:
+            self.totalpot = 0
+            
+            # player names: 
+            # print [x[1] for x in self.players]
+            for player in [x[1] for x in self.players]:
+                for street in self.STREETS:
+                    print street, self.bets[street][player]
+                    self.totalpot += reduce(operator.add, self.bets[street][player], 0)
+                    
 
 
-	def printHand(self):
-		# PokerStars format.
-		print "### DEBUG ###"
-		print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, "XXXXhand.gametype", self.sb, self.bb, self.starttime)
-		print "Table '%s' %d-max Seat #%s is the button" %(self.tablename, self.maxseats, self.buttonpos)
-		for player in self.players:
-			print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
+    def printHand(self):
+        # PokerStars format.
+        print "### DEBUG ###"
+        print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, "XXXXhand.gametype", self.sb, self.bb, self.starttime)
+        print "Table '%s' %d-max Seat #%s is the button" %(self.tablename, self.maxseats, self.buttonpos)
+        for player in self.players:
+            print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
 
-		if(self.posted[0] is None):
-			print "No small blind posted"
-		else:
-			print "%s: posts small blind $%s" %(self.posted[0], self.sb)
+        if(self.posted[0] is None):
+            print "No small blind posted"
+        else:
+            print "%s: posts small blind $%s" %(self.posted[0], self.sb)
 
-		#May be more than 1 bb posting
-		for a in self.posted[1:]:
-			print "%s: posts big blind $%s" %(self.posted[1], self.bb)
-			
-		# What about big & small blinds?
+        #May be more than 1 bb posting
+        for a in self.posted[1:]:
+            print "%s: posts big blind $%s" %(self.posted[1], self.bb)
+            
+        # What about big & small blinds?
 
-		print "*** HOLE CARDS ***"
-		print "Dealt to %s [%s %s]" %(self.hero , self.holecards[0], self.holecards[1])
+        print "*** HOLE CARDS ***"
+        print "Dealt to %s [%s %s]" %(self.hero , self.holecards[0], self.holecards[1])
 
-		if 'PREFLOP' in self.actions:
-			for act in self.actions['PREFLOP']:
-				self.printActionLine(act)
+        if 'PREFLOP' in self.actions:
+            for act in self.actions['PREFLOP']:
+                self.printActionLine(act)
 
-		if 'FLOP' in self.actions:
-			print "*** FLOP *** [%s %s %s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"))
-			for act in self.actions['FLOP']:
-				self.printActionLine(act)
+        if 'FLOP' in self.actions:
+            print "*** FLOP *** [%s %s %s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"))
+            for act in self.actions['FLOP']:
+                self.printActionLine(act)
 
-		if 'TURN' in self.actions:
-			print "*** TURN *** [%s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"))
-			for act in self.actions['TURN']:
-				self.printActionLine(act)
+        if 'TURN' in self.actions:
+            print "*** TURN *** [%s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"))
+            for act in self.actions['TURN']:
+                self.printActionLine(act)
 
-		if 'RIVER' in self.actions:
-			print "*** RIVER *** [%s %s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
-			for act in self.actions['RIVER']:
-				self.printActionLine(act)
-				
-				
-		#Some sites don't have a showdown section so we have to figure out if there should be one
-		# The logic for a showdown is: at the end of river action there are at least two players in the hand
-		if 'SHOWDOWN' in self.actions:
-			print "*** SHOW DOWN ***"
-			print "what do they show"
-		
-		print "*** SUMMARY ***"
-		print "Total pot $%s | Rake $%s)" % (self.totalpot, self.rake)
-		print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+        if 'RIVER' in self.actions:
+            print "*** RIVER *** [%s %s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+            for act in self.actions['RIVER']:
+                self.printActionLine(act)
+                
+                
+        #Some sites don't have a showdown section so we have to figure out if there should be one
+        # The logic for a showdown is: at the end of river action there are at least two players in the hand
+        if 'SHOWDOWN' in self.actions:
+            print "*** SHOW DOWN ***"
+            print "what do they show"
+        
+        print "*** SUMMARY ***"
+        print "Total pot $%s | Rake $%s)" % (self.totalpot, self.rake)
+        print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
 
 
-	def printActionLine(self, act):
-		if act[1] == 'folds' or act[1] == 'checks':
-			print "%s: %s " %(act[0], act[1])
-		if act[1] == 'calls':
-			print "%s: %s $%s" %(act[0], act[1], act[2])
-		if act[1] == 'raises':
-			print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
\ No newline at end of file
+    def printActionLine(self, act):
+        if act[1] == 'folds' or act[1] == 'checks':
+            print "%s: %s " %(act[0], act[1])
+        if act[1] == 'calls':
+            print "%s: %s $%s" %(act[0], act[1], act[2])
+        if act[1] == 'raises':
+            print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
\ No newline at end of file

From 4f44eff3daa9a2285757da6389fac55cc55018ff Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Mon, 8 Dec 2008 06:23:50 +0000
Subject: [PATCH 03/12] getting somewhere, very messy, using pokereval, not
 sure if this is right direction, comments please

---
 pyfpdb/EverleafToFpdb.py       |  30 ++++++--
 pyfpdb/HandHistoryConverter.py | 133 +++++++++++++++++++++++++++------
 2 files changed, 135 insertions(+), 28 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index d60211b6..1a1196c5 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -66,7 +66,7 @@ from HandHistoryConverter import *
 class Everleaf(HandHistoryConverter):
     def __init__(self, config, file):
         print "Initialising Everleaf converter class"
-        HandHistoryConverter.__init__(self, config, file, "Everleaf") # Call super class init.
+        HandHistoryConverter.__init__(self, config, file, sitename="Everleaf") # Call super class init.
         self.sitename = "Everleaf"
         self.setFileType("text")
         self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
@@ -78,6 +78,7 @@ class Everleaf(HandHistoryConverter):
         # mct : what about posting small & big blinds simultaneously?
         self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLE1>\S\S), (?P<HOLE2>\S\S) \]')
         self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*) (?P<ATYPE>bets|checks|raises|calls|folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
+        self.rexx.setShowdownActionRegex('.*\n(?P<PNAME>.*) shows \[ (?P<CARDS>.*) \]')
         self.rexx.compileRegexes()
 
     def readSupportedGames(self):
@@ -118,8 +119,7 @@ class Everleaf(HandHistoryConverter):
         players = []
 
         for a in m:
-            hand.addPlayer(a.group('SEAT'), a.group('PNAME'), a.group('CASH'))
-
+            hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
         # PREFLOP = ** Dealing down cards **
@@ -128,6 +128,17 @@ class Everleaf(HandHistoryConverter):
 #			print "DEBUG: Street: %s\tspan: %s" %(street, str(m.span(street)))
         hand.streets = m
 
+    def readCommunityCards(self, hand):
+        # currently regex in wrong place pls fix my brain's fried
+        # what a mess!
+        re_board = re.compile('\*\* Dealing (?P<STREET>.*) \*\* \[ (?P<CARDS>.*) \]')
+        m = re_board.finditer(hand.string)
+        for street in m:
+            #print street.groups()
+            re_card = re.compile('(?P<CARD>[0-9tjqka][schd])') # look that's weird, hole cards have a capital rank but board cards are lower case?
+            cardsmatch = re_card.finditer(street.group('CARDS'))
+            hand.setCommunityCards(street.group('STREET'), [card.group('CARD') for card in cardsmatch])
+
     def readBlinds(self, hand):
         try:
             m = self.rexx.small_blind_re.search(hand.string)
@@ -148,7 +159,7 @@ class Everleaf(HandHistoryConverter):
             hand.involved = False
         else:
             hand.hero = m.group('PNAME')
-            hand.addHoleCards(m.group('HOLE1'), m.group('HOLE2'))
+            hand.addHoleCards([m.group('HOLE1'), m.group('HOLE2')], m.group('PNAME'))
 
     def readAction(self, hand, street):
         m = self.rexx.action_re.finditer(hand.streets.group(street))
@@ -161,10 +172,19 @@ class Everleaf(HandHistoryConverter):
             elif action.group('ATYPE') == 'bets':
                 hand.addBet( street, action.group('PNAME'), action.group('BET') )
             else:
-                print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
+                #print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
                 hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
 
 
+    def readShowdownActions(self, hand):
+        for shows in self.rexx.showdown_action_re.finditer(hand.string):
+            print shows.groups()
+            re_card = re.compile('(?P<CARD>[0-9tjqka][schd])')  # copied from earlier
+            cards = [card.group('CARD') for card in re_card.finditer(shows.group('CARDS'))]
+            print cards
+            hand.addHoleCards(cards, shows.group('PNAME'))
+            
+
     def getRake(self, hand):
         hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right
 
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 71bc0b25..06a59064 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -26,10 +26,13 @@ import xml.dom.minidom
 from decimal import Decimal
 import operator
 from xml.dom.minidom import Node
+from pokereval import PokerEval
 
 class HandHistoryConverter:
+    eval = PokerEval()
     def __init__(self, config, file, sitename):
         print "HandHistory init called"
+
         self.c         = config
         self.sitename  = sitename
         self.obs       = ""             # One big string
@@ -68,8 +71,9 @@ class HandHistoryConverter:
             self.readPlayerStacks(hand)
             self.markStreets(hand)
             self.readBlinds(hand)
-            self.readHeroCards(hand)
-
+            self.readHeroCards(hand) # want to generalise to draw games
+            self.readCommunityCards(hand) # read community cards
+            self.readShowdownActions(hand)
             # Read action (Note: no guarantee this is in hand order.
             for street in hand.streets.groupdict():
                 self.readAction(hand, street)
@@ -198,10 +202,7 @@ class HandHistoryConverter:
 
         print "*** HOLE CARDS ***"
         print "Dealt to %s [%s %s]" %(hand.hero , hand.holecards[0], hand.holecards[1])
-#
-##		ACTION STUFF
-#		This is no limit only at the moment
-        
+
         for act in hand.actions['PREFLOP']:
             self.printActionLine(act, 0)
 
@@ -226,10 +227,6 @@ class HandHistoryConverter:
 
         print "*** SUMMARY ***"
         print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
-#		print "Total pot $%s | Rake $%s)" %(hand.totalpot  $" + hand.rake)
-#		print "Board [" + boardcards + "]"
-#
-#		SUMMARY STUFF
 
 
     def printActionLine(self, act, pot):
@@ -239,7 +236,7 @@ class HandHistoryConverter:
             print "%s: %s $%s" %(act[0], act[1], act[2])
         if act[1] == 'raises':
             print "%s: %s $%s to XXXpottotalXXX" %(act[0], act[1], act[2])
-            
+
 
 #takes a poker float (including , for thousand seperator and converts it to an int
     def float2int (self, string):
@@ -261,13 +258,13 @@ class Hand:
 #    def __init__(self, sitename, gametype, sb, bb, string):
 
     UPS = {'a':'A', 't':'T', 'j':'J', 'q':'Q', 'k':'K'}
-    STREETS = ['BLINDS','PREFLOP','FLOP','TURN','RIVER']
     def __init__(self, sitename, gametype, string):
         self.sitename = sitename
         self.gametype = gametype
         self.string = string
     
         self.streets = None # A MatchObject using a groupnames to identify streets.
+        self.streetList = ['BLINDS','PREFLOP','FLOP','TURN','RIVER'] # a list of the observed street names in order
         self.actions = {}
     
         self.handid = 0
@@ -281,15 +278,18 @@ class Hand:
         self.players = []
         self.posted = []
         self.involved = True
+        
         self.hero = "Hiro"
-        self.holecards = "Xx Xx"
+        self.holecards = {} # dict from player names to lists of hole cards
+        self.board = {}     # dict from street names to community cards
+        
         self.action = []
         self.totalpot = None
         self.rake = None
         
         self.bets = {}
         self.lastBet = {}
-        for street in self.STREETS:
+        for street in self.streetList:
             self.bets[street] = {}
             self.lastBet[street] = 0
             
@@ -299,20 +299,36 @@ class Hand:
         chips, the chips the player has at the start of the hand"""
         #self.players.append(name)
         self.players.append([seat, name, chips])
+        self.holecards[name] = []
         #self.startChips[name] = chips
         #self.endChips[name] = chips
         #self.winners[name] = 0
-        for street in self.STREETS:
+        for street in self.streetList:
             self.bets[street][name] = []
 
 
-    def addHoleCards(self,h1,h2,seat=None): # generalise to add hole cards for a specific seat or player
-        self.holecards = [self.card(h1), self.card(h2)]
+    def addHoleCards(self, cards, player=None): # generalise to add hole cards for a specific seat or player
+        for c in cards:
+            self.holecards[player].append(self.card(c))
 
 
+    def discardHoleCards(self, cards, player=None):
+        if seat is None:
+            #raise something
+            pass
+        for card in cards:
+            try:
+                self.holecards[player].remove(card)
+            except ValueError:
+                print "tried to discard a card player apparently didn't have"
+
+    def setCommunityCards(self, street, cards):
+        self.board[street] = [self.card(c) for c in cards]
+        print self.board[street]
+
     def card(self,c):
         """upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""
-    # don't know how to make this 'static'
+        # don't know how to make this 'static'
         for k,v in self.UPS.items():
             c = c.replace(k,v)
         return c
@@ -325,6 +341,13 @@ class Hand:
         self.posted += [player]
         
 
+    #def addFold(self, street, player=None):
+        ## Called when a player folds.
+        #self.bets[street][player].append(None)
+
+    #def addCheck(self, street, player=None):
+        #self.bets[street][player].append(0)
+
     def addCall(self, street, player=None, amount=None):
         # Potentially calculate the amount of the call if not supplied
         # corner cases include if player would be all in
@@ -352,15 +375,16 @@ class Hand:
         self.actions[street] += [[player, 'bets', amount]]
         
     def totalPot(self):
-        
+        """If all bets and blinds have been added, totals up the total pot size
+Known bug: doesn't take into account side pots"""
         if self.totalpot is None:
             self.totalpot = 0
             
             # player names: 
             # print [x[1] for x in self.players]
             for player in [x[1] for x in self.players]:
-                for street in self.STREETS:
-                    print street, self.bets[street][player]
+                for street in self.streetList:
+                    #print street, self.bets[street][player]
                     self.totalpot += reduce(operator.add, self.bets[street][player], 0)
                     
 
@@ -385,7 +409,7 @@ class Hand:
         # What about big & small blinds?
 
         print "*** HOLE CARDS ***"
-        print "Dealt to %s [%s %s]" %(self.hero , self.holecards[0], self.holecards[1])
+        print "Dealt to %s [%s %s]" %(self.hero , self.holecards[self.hero][0], self.holecards[self.hero][1])
 
         if 'PREFLOP' in self.actions:
             for act in self.actions['PREFLOP']:
@@ -416,6 +440,19 @@ class Hand:
         print "*** SUMMARY ***"
         print "Total pot $%s | Rake $%s)" % (self.totalpot, self.rake)
         print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+        
+        #print self.board
+        for player in self.players:
+            if self.holecards[player[1]]: # empty list default is false
+                hole = self.holecards[player[1]]
+                #print self.board.values()
+                board = []
+                for s in self.board.values():
+                    board += s
+                playerhand = self.bestHand('hi', board+hole)
+                print "Seat %d: %s showed %s and won/lost with %s" % (player[0], player[1], hole, playerhand)
+            else:
+                print "Seat %d: %s mucked or folded" % (player[0], player[1])
 
 
     def printActionLine(self, act):
@@ -424,4 +461,54 @@ class Hand:
         if act[1] == 'calls':
             print "%s: %s $%s" %(act[0], act[1], act[2])
         if act[1] == 'raises':
-            print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
\ No newline at end of file
+            print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
+
+    # going to use pokereval to figure out hands
+    # these functions are copied from pokergame.py
+    # im thinking perhaps its best to use all the functionality of pokergame instead
+    # of reinventing the wheel
+    def bestHand(self, side, cards):
+        #if self.variant == "omaha" or self.variant == "omaha8":
+        #hand = self.serial2player[serial].hand.tolist(True)
+        #board = self.board.tolist(True)
+        #else:
+        #hand = hand.tolist(True) + board.tolist(True)
+        #board = []
+        print cards
+        return HandHistoryConverter.eval.best('hi', cards, [])
+
+    def bestHandValue(self, side, serial):
+        (value, cards) = self.bestHand(side, serial)
+        return value
+
+
+    def readableHandValueLong(self, side, value, cards):
+        cards = self.eval.card2string(cards)
+        if value == "NoPair":
+            if side == "low":
+                if cards[0][0] == '5':
+                    return _("The wheel")
+                else:
+                    return join(map(lambda card: card[0], cards), ", ")
+            else:
+                return _("High card %(card)s") % { 'card' : _(letter2name[cards[0][0]]) }
+        elif value == "OnePair":
+            return _("A pair of %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[2][0]]) }
+        elif value == "TwoPair":
+            return _("Two pairs %(card1)s and %(card2)s") % { 'card1' : _(letter2names[cards[0][0]]), 'card2' : _(letter2names[cards[2][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[4][0]]) }
+        elif value == "Trips":
+            return _("Three of a kind %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[3][0]]) }
+        elif value == "Straight":
+            return _("Straight %(card1)s to %(card2)s") % { 'card1' : _(letter2name[cards[0][0]]), 'card2' : _(letter2name[cards[4][0]]) }
+        elif value == "Flush":
+            return _("Flush %(card)s high") % { 'card' : _(letter2name[cards[0][0]]) }
+        elif value == "FlHouse":
+            return _("%(card1)ss full of %(card2)ss") % { 'card1' : _(letter2name[cards[0][0]]), 'card2' : _(letter2name[cards[3][0]]) }
+        elif value == "Quads":
+            return _("Four of a kind %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[4][0]]) }
+        elif value == "StFlush":
+            if letter2name[cards[0][0]] == 'Ace':
+                return _("Royal flush")
+            else:
+                return _("Straight flush %(card)s high") % { 'card' : _(letter2name[cards[0][0]]) }
+        return value
\ No newline at end of file

From 2d6412c8a797ffaa8bc85a998cb277b611e969d1 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Tue, 9 Dec 2008 15:32:37 +0000
Subject: [PATCH 04/12] pseudo stars!

---
 pyfpdb/EverleafToFpdb.py       |   7 ++
 pyfpdb/HandHistoryConverter.py | 114 +++++++++++----------------------
 2 files changed, 46 insertions(+), 75 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 1a1196c5..a5aa5514 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -79,6 +79,7 @@ class Everleaf(HandHistoryConverter):
         self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLE1>\S\S), (?P<HOLE2>\S\S) \]')
         self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*) (?P<ATYPE>bets|checks|raises|calls|folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
         self.rexx.setShowdownActionRegex('.*\n(?P<PNAME>.*) shows \[ (?P<CARDS>.*) \]')
+        self.rexx.setCollectPotRegex('.*\n(?P<PNAME>.*) wins \$ (?P<POT>[.\d]+) USD.*')
         self.rexx.compileRegexes()
 
     def readSupportedGames(self):
@@ -184,6 +185,12 @@ class Everleaf(HandHistoryConverter):
             print cards
             hand.addHoleCards(cards, shows.group('PNAME'))
             
+    def readCollectPot(self,hand):
+        m = self.rexx.collect_pot_re.search(hand.string)
+        print m.groups()
+        print m.group('PNAME')
+        #for collection in m:
+        hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
 
     def getRake(self, hand):
         hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 06a59064..5e6804c5 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -78,6 +78,8 @@ class HandHistoryConverter:
             for street in hand.streets.groupdict():
                 self.readAction(hand, street)
 
+            self.readCollectPot(hand)
+
             # finalise it (total the pot)
             hand.totalPot()
             self.getRake(hand)
@@ -124,6 +126,7 @@ class HandHistoryConverter:
     def readBlinds(self, hand): abstract
     def readHeroCards(self, hand): abstract
     def readAction(self, hand, street): abstract
+    def readCollectPot(self, hand): abstract
     
     # Some sites don't report the rake. This will be called at the end of the hand after the pot total has been calculated
     # so that an inheriting class can calculate it for the specific site if need be.
@@ -177,66 +180,6 @@ class HandHistoryConverter:
             except:
                 traceback.print_exc(file=sys.stderr)
 
-    def writeHand(self, file, hand):
-        """Write out parsed data"""
-        print "DEBUG: *************************"
-        print "DEBUG: Start of print hand"
-        print "DEBUG: *************************"
-
-        print "%s Game #%s: %s ($%s/$%s) - %s" %(hand.sitename, hand.handid, "XXXXhand.gametype", hand.sb, hand.bb, hand.starttime)
-        print "Table '%s' %d-max Seat #%s is the button" %(hand.tablename, hand.maxseats, hand.buttonpos)
-
-        for player in hand.players:
-            print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
-
-        if(hand.posted[0] == "FpdbNBP"):
-            print "No small blind posted"
-        else:
-            print "%s: posts small blind $%s" %(hand.posted[0], hand.sb)
-
-        #May be more than 1 bb posting
-        print "%s: posts big blind $%s" %(hand.posted[1], hand.bb)
-        if(len(hand.posted) > 2):
-            # Need to loop on all remaining big blinds - lazy
-            print "XXXXXXXXX FIXME XXXXXXXX"
-
-        print "*** HOLE CARDS ***"
-        print "Dealt to %s [%s %s]" %(hand.hero , hand.holecards[0], hand.holecards[1])
-
-        for act in hand.actions['PREFLOP']:
-            self.printActionLine(act, 0)
-
-        if 'PREFLOP' in hand.actions:
-            for act in hand.actions['PREFLOP']:
-                print "PF action"
-
-        if 'FLOP' in hand.actions:
-            print "*** FLOP *** [%s %s %s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"))
-            for act in hand.actions['FLOP']:
-                self.printActionLine(act, 0)
-
-        if 'TURN' in hand.actions:
-            print "*** TURN *** [%s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"))
-            for act in hand.actions['TURN']:
-                self.printActionLine(act, 0)
-
-        if 'RIVER' in hand.actions:
-            print "*** RIVER *** [%s %s %s %s] [%s]" %(hand.streets.group("FLOP1"), hand.streets.group("FLOP2"), hand.streets.group("FLOP3"), hand.streets.group("TURN1"), hand.streets.group("RIVER1"))
-            for act in hand.actions['RIVER']:
-                self.printActionLine(act, 0)
-
-        print "*** SUMMARY ***"
-        print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
-
-
-    def printActionLine(self, act, pot):
-        if act[1] == 'folds' or act[1] == 'checks':
-            print "%s: %s " %(act[0], act[1])
-        if act[1] == 'calls':
-            print "%s: %s $%s" %(act[0], act[1], act[2])
-        if act[1] == 'raises':
-            print "%s: %s $%s to XXXpottotalXXX" %(act[0], act[1], act[2])
-
 
 #takes a poker float (including , for thousand seperator and converts it to an int
     def float2int (self, string):
@@ -282,6 +225,7 @@ class Hand:
         self.hero = "Hiro"
         self.holecards = {} # dict from player names to lists of hole cards
         self.board = {}     # dict from street names to community cards
+        self.collected = {} # dict from player names to amounts collected
         
         self.action = []
         self.totalpot = None
@@ -373,7 +317,16 @@ class Hand:
         self.bets[street][name].append(Decimal(amount))
         self.orderedBets[street].append(Decimal(amount))
         self.actions[street] += [[player, 'bets', amount]]
-        
+
+    def addCollectPot(self,player, pot):
+        if player not in self.collected:
+            self.collected[player] = pot
+        else:
+            # possibly lines like "p collected $ from pot" appear during the showdown
+            # but they are usually unique in the summary.
+            print "%s collected pot more than once; avoidable by reading winnings only from summary lines?"
+
+
     def totalPot(self):
         """If all bets and blinds have been added, totals up the total pot size
 Known bug: doesn't take into account side pots"""
@@ -443,16 +396,29 @@ Known bug: doesn't take into account side pots"""
         
         #print self.board
         for player in self.players:
-            if self.holecards[player[1]]: # empty list default is false
-                hole = self.holecards[player[1]]
-                #print self.board.values()
-                board = []
-                for s in self.board.values():
-                    board += s
-                playerhand = self.bestHand('hi', board+hole)
-                print "Seat %d: %s showed %s and won/lost with %s" % (player[0], player[1], hole, playerhand)
+            if player[1] in self.collected and self.holecards[player[1]]:
+                print "Seat %d: %s showed [%s %s] and won ($%s)" % (player[0], player[1], self.holecards[player[1]][0], self.holecards[player[1]][1], self.collected[player[1]])
+            elif player[1] in self.collected:
+                print "Seat %d: %s collected ($%s)" % (player[0], player[1], self.collected[player[1]])
+            elif self.holecards[player[1]]:
+                print "Seat %d: %s showed [%s %s]" % (player[0], player[1], self.holecards[player[1]][0], self.holecards[player[1]][1])
             else:
-                print "Seat %d: %s mucked or folded" % (player[0], player[1])
+                print "Seat %d: %s folded (or mucked..)" % (player[0], player[1])
+            
+            # TODO:
+            # logic for side pots
+            # logic for which players get to showdown
+            # I'm just not sure we need to do this so heavily.. and if we do, it's probably better to use pokerlib
+            #if self.holecards[player[1]]: # empty list default is false
+                #hole = self.holecards[player[1]]
+                ##board = []
+                ##for s in self.board.values():
+                    ##board += s
+                ##playerhand = self.bestHand('hi', board+hole)
+                ##print "Seat %d: %s showed %s and won/lost with %s" % (player[0], player[1], hole, playerhand)
+                #print "Seat %d: %s showed %s" % (player[0], player[1], hole)
+            #else:
+                #print "Seat %d: %s mucked or folded" % (player[0], player[1])
 
 
     def printActionLine(self, act):
@@ -463,10 +429,8 @@ Known bug: doesn't take into account side pots"""
         if act[1] == 'raises':
             print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
 
-    # going to use pokereval to figure out hands
+    # going to use pokereval to figure out hands at some point.
     # these functions are copied from pokergame.py
-    # im thinking perhaps its best to use all the functionality of pokergame instead
-    # of reinventing the wheel
     def bestHand(self, side, cards):
         #if self.variant == "omaha" or self.variant == "omaha8":
         #hand = self.serial2player[serial].hand.tolist(True)
@@ -477,13 +441,13 @@ Known bug: doesn't take into account side pots"""
         print cards
         return HandHistoryConverter.eval.best('hi', cards, [])
 
+    # from pokergame.py
     def bestHandValue(self, side, serial):
         (value, cards) = self.bestHand(side, serial)
         return value
 
-
+    # from pokergame.py
     def readableHandValueLong(self, side, value, cards):
-        cards = self.eval.card2string(cards)
         if value == "NoPair":
             if side == "low":
                 if cards[0][0] == '5':

From 7ac433fede89103c91b84447318b2c2f9a0f6105 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Tue, 9 Dec 2008 15:35:16 +0000
Subject: [PATCH 05/12] 2 decimal places for rake

---
 pyfpdb/HandHistoryConverter.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 5e6804c5..63b51bb0 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -391,7 +391,7 @@ Known bug: doesn't take into account side pots"""
             print "what do they show"
         
         print "*** SUMMARY ***"
-        print "Total pot $%s | Rake $%s)" % (self.totalpot, self.rake)
+        print "Total pot $%s | Rake $%.2f)" % (self.totalpot, self.rake) # TODO side pots
         print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
         
         #print self.board

From 6b0dcc37d42ecea4f1f23b337e74709cd5f34c1a Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Tue, 9 Dec 2008 23:30:58 +0000
Subject: [PATCH 06/12] I set it up with Speed_Kuala_full.txt and now it's time
 to go through them all fixing the bugs.

---
 pyfpdb/EverleafToFpdb.py       | 38 ++++++++++++----
 pyfpdb/HandHistoryConverter.py | 82 ++++++++++++++++++++++++++--------
 2 files changed, 94 insertions(+), 26 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index a5aa5514..e1f9bcbf 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -70,7 +70,7 @@ class Everleaf(HandHistoryConverter):
         self.sitename = "Everleaf"
         self.setFileType("text")
         self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
-        self.rexx.setSplitHandRegex('\n\n\n\n')
+        self.rexx.setSplitHandRegex('\n\n+')
         self.rexx.setHandInfoRegex('.*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<YEAR>[0-9]+)/(?P<MON>[0-9]+)/(?P<DAY>[0-9]+) - (?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)\nTable (?P<TABLE>[ a-zA-Z]+)\nSeat (?P<BUTTON>[0-9]+)')
         self.rexx.setPlayerInfoRegex('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(  \$ (?P<CASH>[.0-9]+) USD \)')
         self.rexx.setPostSbRegex('.*\n(?P<PNAME>.*): posts small blind \[\$? (?P<SB>[.0-9]+)')
@@ -118,16 +118,38 @@ class Everleaf(HandHistoryConverter):
     def readPlayerStacks(self, hand):
         m = self.rexx.player_info_re.finditer(hand.string)
         players = []
-
+        print "players seen:"
         for a in m:
+            print a.group('PNAME')
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
         # PREFLOP = ** Dealing down cards **
-        m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
-#		for street in m.groupdict():
-#			print "DEBUG: Street: %s\tspan: %s" %(street, str(m.span(street)))
+        # This re fails if,  say, river is missing; then we don't get the ** that starts the river.
+        #m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
+
+        m =  re.search(r"\*\* Dealing down cards \*\*(?P<PREFLOP>.+(?=\*\* Dealing Flop \*\*)|.+)"
+                       r"(\*\* Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \](?P<FLOP>.+(?=\*\* Dealing Turn \*\*)|.+))?"
+                       r"(\*\* Dealing Turn \*\* \[ (?P<TURN1>\S\S) \](?P<TURN>.+(?=\*\* Dealing River \*\*)|.+))?"
+                       r"(\*\* Dealing River \*\* \[ (?P<RIVER1>\S\S) \](?P<RIVER>.+))?", hand.string,re.DOTALL)
+        # that wasn't easy.
+
+
+        #m1 = re.search(r'(\*\* Dealing down cards \*\*)?(?P<PREFLOP>.*?\n\*\*)',hand.string,re.DOTALL)
+        #m2 = re.search(r'(\*\* Dealing Flop \*\*)?(?P<FLOP>.*\n\*\*)',hand.string,re.DOTALL)
+        #print hand.string
+        #print "m  groups:\n",m.groupdict()
+        #print "m1 groups:\n",m1.groupdict()
+        #print "m2 groups:\n",m2.groupdict()
+        #(\*\* Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \](?P<FLOP>.*?)?)?
+        #(\*\* Dealing Turn \*\* \[ (?P<TURN1>\S\S) \](?P<TURN>.*?))?
+        #(\*\* Dealing River \*\* \[ (?P<RIVER1>\S\S) \](?P<RIVER>.*?))?', hand.string,re.DOTALL)
+        
+        
+        #for street in m.groupdict():
+            #print "DEBUG: Street: %s\tspan: %s" %(street, str(m.span(street)))
         hand.streets = m
+        #sys.exit()
 
     def readCommunityCards(self, hand):
         # currently regex in wrong place pls fix my brain's fried
@@ -187,8 +209,8 @@ class Everleaf(HandHistoryConverter):
             
     def readCollectPot(self,hand):
         m = self.rexx.collect_pot_re.search(hand.string)
-        print m.groups()
-        print m.group('PNAME')
+        #print m.groups()
+        #print m.group('PNAME')
         #for collection in m:
         hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
 
@@ -197,7 +219,7 @@ class Everleaf(HandHistoryConverter):
 
 if __name__ == "__main__":
     c = Configuration.Config()
-    e = Everleaf(c, "Speed_Kuala.txt")
+    e = Everleaf(c, "Speed_Kuala_full.txt")
     e.processFile()
     print str(e)
     
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 63b51bb0..8ca1c47a 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -28,6 +28,41 @@ import operator
 from xml.dom.minidom import Node
 from pokereval import PokerEval
 
+#from pokerengine.pokercards import *
+# provides letter2name{}, letter2names{}, visible_card(), not_visible_card(), is_visible(), card_value(), class PokerCards
+# but it's probably not installed so here are the ones we may want:
+letter2name = {
+    'A': 'Ace',
+    'K': 'King',
+    'Q': 'Queen',
+    'J': 'Jack',
+    'T': 'Ten',
+    '9': 'Nine',
+    '8': 'Eight',
+    '7': 'Seven',
+    '6': 'Six',
+    '5': 'Five',
+    '4': 'Four',
+    '3': 'Trey',
+    '2': 'Deuce'
+    }
+
+letter2names = {
+    'A': 'Aces',
+    'K': 'Kings',
+    'Q': 'Queens',
+    'J': 'Jacks',
+    'T': 'Tens',
+    '9': 'Nines',
+    '8': 'Eights',
+    '7': 'Sevens',
+    '6': 'Sixes',
+    '5': 'Fives',
+    '4': 'Fours',
+    '3': 'Treys',
+    '2': 'Deuces'
+    }
+
 class HandHistoryConverter:
     eval = PokerEval()
     def __init__(self, config, file, sitename):
@@ -67,6 +102,7 @@ class HandHistoryConverter:
         self.gametype = self.determineGameType()
         self.hands = self.splitFileIntoHands()
         for hand in self.hands:
+            print "DEBUG:\n"+hand.string
             self.readHandInfo(hand)
             self.readPlayerStacks(hand)
             self.markStreets(hand)
@@ -76,7 +112,8 @@ class HandHistoryConverter:
             self.readShowdownActions(hand)
             # Read action (Note: no guarantee this is in hand order.
             for street in hand.streets.groupdict():
-                self.readAction(hand, street)
+                if hand.streets.group(street) is not None:
+                    self.readAction(hand, street)
 
             self.readCollectPot(hand)
 
@@ -84,11 +121,12 @@ class HandHistoryConverter:
             hand.totalPot()
             self.getRake(hand)
             
-            if(hand.involved == True):
+            hand.printHand()
+            #if(hand.involved == True):
                 #self.writeHand("output file", hand)
-                hand.printHand()
-            else:
-                pass #Don't write out observed hands
+                #hand.printHand()
+            #else:
+                #pass #Don't write out observed hands
 
     #####
     # These functions are parse actions that may be overridden by the inheriting class
@@ -159,6 +197,7 @@ class HandHistoryConverter:
 
     def splitFileIntoHands(self):
         hands = []
+        self.obs.strip()
         list = self.rexx.split_hand_re.split(self.obs)
         list.pop() #Last entry is empty
         for l in list:
@@ -280,6 +319,7 @@ class Hand:
     def addBlind(self, player, amount):
         # if player is None, it's a missing small blind.
         if player is not None:
+            print self.bets
             self.bets['PREFLOP'][player].append(Decimal(amount))
         self.lastBet['PREFLOP'] = Decimal(amount)
         self.posted += [player]
@@ -362,7 +402,8 @@ Known bug: doesn't take into account side pots"""
         # What about big & small blinds?
 
         print "*** HOLE CARDS ***"
-        print "Dealt to %s [%s %s]" %(self.hero , self.holecards[self.hero][0], self.holecards[self.hero][1])
+        if self.involved:
+            print "Dealt to %s [%s %s]" %(self.hero , self.holecards[self.hero][0], self.holecards[self.hero][1])
 
         if 'PREFLOP' in self.actions:
             for act in self.actions['PREFLOP']:
@@ -392,7 +433,11 @@ Known bug: doesn't take into account side pots"""
         
         print "*** SUMMARY ***"
         print "Total pot $%s | Rake $%.2f)" % (self.totalpot, self.rake) # TODO side pots
-        print "Board [%s %s %s %s %s]" % (self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+        board = []
+        for s in self.board.values():
+            board += s
+        if board:   # sometimes hand ends preflop without a board
+            print "Board [%s]" % (board)
         
         #print self.board
         for player in self.players:
@@ -447,32 +492,33 @@ Known bug: doesn't take into account side pots"""
         return value
 
     # from pokergame.py
+    # got rid of the _ for internationalisation
     def readableHandValueLong(self, side, value, cards):
         if value == "NoPair":
             if side == "low":
                 if cards[0][0] == '5':
-                    return _("The wheel")
+                    return ("The wheel")
                 else:
                     return join(map(lambda card: card[0], cards), ", ")
             else:
-                return _("High card %(card)s") % { 'card' : _(letter2name[cards[0][0]]) }
+                return ("High card %(card)s") % { 'card' : (letter2name[cards[0][0]]) }
         elif value == "OnePair":
-            return _("A pair of %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[2][0]]) }
+            return ("A pair of %(card)s") % { 'card' : (letter2names[cards[0][0]]) } + (", %(card)s kicker") % { 'card' : (letter2name[cards[2][0]]) }
         elif value == "TwoPair":
-            return _("Two pairs %(card1)s and %(card2)s") % { 'card1' : _(letter2names[cards[0][0]]), 'card2' : _(letter2names[cards[2][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[4][0]]) }
+            return ("Two pairs %(card1)s and %(card2)s") % { 'card1' : (letter2names[cards[0][0]]), 'card2' : _(letter2names[cards[2][0]]) } + (", %(card)s kicker") % { 'card' : (letter2name[cards[4][0]]) }
         elif value == "Trips":
-            return _("Three of a kind %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[3][0]]) }
+            return ("Three of a kind %(card)s") % { 'card' : (letter2names[cards[0][0]]) } + (", %(card)s kicker") % { 'card' : (letter2name[cards[3][0]]) }
         elif value == "Straight":
-            return _("Straight %(card1)s to %(card2)s") % { 'card1' : _(letter2name[cards[0][0]]), 'card2' : _(letter2name[cards[4][0]]) }
+            return ("Straight %(card1)s to %(card2)s") % { 'card1' : (letter2name[cards[0][0]]), 'card2' : (letter2name[cards[4][0]]) }
         elif value == "Flush":
-            return _("Flush %(card)s high") % { 'card' : _(letter2name[cards[0][0]]) }
+            return ("Flush %(card)s high") % { 'card' : (letter2name[cards[0][0]]) }
         elif value == "FlHouse":
-            return _("%(card1)ss full of %(card2)ss") % { 'card1' : _(letter2name[cards[0][0]]), 'card2' : _(letter2name[cards[3][0]]) }
+            return ("%(card1)ss full of %(card2)ss") % { 'card1' : (letter2name[cards[0][0]]), 'card2' : (letter2name[cards[3][0]]) }
         elif value == "Quads":
-            return _("Four of a kind %(card)s") % { 'card' : _(letter2names[cards[0][0]]) } + _(", %(card)s kicker") % { 'card' : _(letter2name[cards[4][0]]) }
+            return _("Four of a kind %(card)s") % { 'card' : (letter2names[cards[0][0]]) } + (", %(card)s kicker") % { 'card' : (letter2name[cards[4][0]]) }
         elif value == "StFlush":
             if letter2name[cards[0][0]] == 'Ace':
-                return _("Royal flush")
+                return ("Royal flush")
             else:
-                return _("Straight flush %(card)s high") % { 'card' : _(letter2name[cards[0][0]]) }
+                return ("Straight flush %(card)s high") % { 'card' : (letter2name[cards[0][0]]) }
         return value
\ No newline at end of file

From e8810839f9b4944692f938954e544ff50ef193d0 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Tue, 9 Dec 2008 23:38:16 +0000
Subject: [PATCH 07/12] bit less mess

---
 pyfpdb/EverleafToFpdb.py       | 2 +-
 pyfpdb/HandHistoryConverter.py | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index e1f9bcbf..7c68749a 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -118,7 +118,7 @@ class Everleaf(HandHistoryConverter):
     def readPlayerStacks(self, hand):
         m = self.rexx.player_info_re.finditer(hand.string)
         players = []
-        print "players seen:"
+        print "\nReading stacks - players seen:"
         for a in m:
             print a.group('PNAME')
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 8ca1c47a..aa4dc56a 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -102,7 +102,7 @@ class HandHistoryConverter:
         self.gametype = self.determineGameType()
         self.hands = self.splitFileIntoHands()
         for hand in self.hands:
-            print "DEBUG:\n"+hand.string
+            print "\nInput:\n"+hand.string
             self.readHandInfo(hand)
             self.readPlayerStacks(hand)
             self.markStreets(hand)
@@ -319,7 +319,6 @@ class Hand:
     def addBlind(self, player, amount):
         # if player is None, it's a missing small blind.
         if player is not None:
-            print self.bets
             self.bets['PREFLOP'][player].append(Decimal(amount))
         self.lastBet['PREFLOP'] = Decimal(amount)
         self.posted += [player]
@@ -384,7 +383,7 @@ Known bug: doesn't take into account side pots"""
 
     def printHand(self):
         # PokerStars format.
-        print "### DEBUG ###"
+        print "### Pseudo stars format ###"
         print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, "XXXXhand.gametype", self.sb, self.bb, self.starttime)
         print "Table '%s' %d-max Seat #%s is the button" %(self.tablename, self.maxseats, self.buttonpos)
         for player in self.players:
@@ -450,6 +449,7 @@ Known bug: doesn't take into account side pots"""
             else:
                 print "Seat %d: %s folded (or mucked..)" % (player[0], player[1])
             
+        print
             # TODO:
             # logic for side pots
             # logic for which players get to showdown

From c9cb2ea7dda760cc9df72bfab1362c307c98fc83 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Tue, 9 Dec 2008 23:58:38 +0000
Subject: [PATCH 08/12] takes care of weirdness with everleaf saying: player
 folds but also player: bets

takes care of double spaces and other junk where stack size is usually reported.
---
 pyfpdb/EverleafToFpdb.py       | 4 ++--
 pyfpdb/HandHistoryConverter.py | 5 ++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 7c68749a..4a8d7d4f 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -72,12 +72,12 @@ class Everleaf(HandHistoryConverter):
         self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
         self.rexx.setSplitHandRegex('\n\n+')
         self.rexx.setHandInfoRegex('.*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<YEAR>[0-9]+)/(?P<MON>[0-9]+)/(?P<DAY>[0-9]+) - (?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)\nTable (?P<TABLE>[ a-zA-Z]+)\nSeat (?P<BUTTON>[0-9]+)')
-        self.rexx.setPlayerInfoRegex('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(  \$ (?P<CASH>[.0-9]+) USD \)')
+        self.rexx.setPlayerInfoRegex('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\s+(\$ (?P<CASH>[.0-9]+) USD|new player|All-in) \)')
         self.rexx.setPostSbRegex('.*\n(?P<PNAME>.*): posts small blind \[\$? (?P<SB>[.0-9]+)')
         self.rexx.setPostBbRegex('.*\n(?P<PNAME>.*): posts big blind \[\$? (?P<BB>[.0-9]+)')
         # mct : what about posting small & big blinds simultaneously?
         self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLE1>\S\S), (?P<HOLE2>\S\S) \]')
-        self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*) (?P<ATYPE>bets|checks|raises|calls|folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
+        self.rexx.setActionStepRegex('.*\n(?P<PNAME>.*)(?P<ATYPE>: bets| checks| raises| calls| folds)(\s\[\$ (?P<BET>[.\d]+) USD\])?')
         self.rexx.setShowdownActionRegex('.*\n(?P<PNAME>.*) shows \[ (?P<CARDS>.*) \]')
         self.rexx.setCollectPotRegex('.*\n(?P<PNAME>.*) wins \$ (?P<POT>[.\d]+) USD.*')
         self.rexx.compileRegexes()
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index aa4dc56a..a6a294c4 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -279,8 +279,7 @@ class Hand:
     def addPlayer(self, seat, name, chips):
         """seat, an int indicating the seat
         name, the player name
-        chips, the chips the player has at the start of the hand"""
-        #self.players.append(name)
+        chips, the chips the player has at the start of the hand (can be None)"""
         self.players.append([seat, name, chips])
         self.holecards[name] = []
         #self.startChips[name] = chips
@@ -353,7 +352,7 @@ class Hand:
         self.actions[street] += [[player, 'raises', amountBy, amountTo]]
         
     def addBet(self, street, player=None, amount=0):
-        self.bets[street][name].append(Decimal(amount))
+        self.bets[street][player].append(Decimal(amount))
         self.orderedBets[street].append(Decimal(amount))
         self.actions[street] += [[player, 'bets', amount]]
 

From 215d5a74b2ca9a725d0f09ae679518a426980e53 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Wed, 10 Dec 2008 00:05:12 +0000
Subject: [PATCH 09/12] If the small blind is dead and it's folded round to big
 blind, no one collects a pot. Warning if we do not see 'collected' line.

---
 pyfpdb/EverleafToFpdb.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 4a8d7d4f..de7823bf 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -209,10 +209,10 @@ class Everleaf(HandHistoryConverter):
             
     def readCollectPot(self,hand):
         m = self.rexx.collect_pot_re.search(hand.string)
-        #print m.groups()
-        #print m.group('PNAME')
-        #for collection in m:
-        hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
+        if m is not None:
+            hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
+        else:
+            print "WARNING: Unusual, no one collected; can happen if it's folded to big blind with a dead small blind."
 
     def getRake(self, hand):
         hand.rake = hand.totalpot * Decimal('0.05') # probably not quite right

From 91105824bdb00fb024885a53cd5102eb47cceaaa Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Wed, 10 Dec 2008 00:48:45 +0000
Subject: [PATCH 10/12] wasn't printing bets and fixed last fix

---
 pyfpdb/EverleafToFpdb.py       | 14 +++++++++-----
 pyfpdb/HandHistoryConverter.py | 29 ++++++++++++++++++++---------
 2 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index de7823bf..ff345194 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -188,15 +188,19 @@ class Everleaf(HandHistoryConverter):
         m = self.rexx.action_re.finditer(hand.streets.group(street))
         hand.actions[street] = []
         for action in m:
-            if action.group('ATYPE') == 'raises':
+            if action.group('ATYPE') == ' raises':
                 hand.addRaiseTo( street, action.group('PNAME'), action.group('BET') )
-            elif action.group('ATYPE') == 'calls':
+            elif action.group('ATYPE') == ' calls':
                 hand.addCall( street, action.group('PNAME'), action.group('BET') )
-            elif action.group('ATYPE') == 'bets':
+            elif action.group('ATYPE') == ': bets':
                 hand.addBet( street, action.group('PNAME'), action.group('BET') )
+            elif action.group('ATYPE') == ' folds':
+                hand.addFold( street, action.group('PNAME'))
+            elif action.group('ATYPE') == ' checks':
+                hand.addCheck( street, action.group('PNAME'))
             else:
-                #print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
-                hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
+                print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
+                #hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
 
 
     def readShowdownActions(self, hand):
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index a6a294c4..5fa83a0e 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -353,9 +353,15 @@ class Hand:
         
     def addBet(self, street, player=None, amount=0):
         self.bets[street][player].append(Decimal(amount))
-        self.orderedBets[street].append(Decimal(amount))
+        #self.orderedBets[street].append(Decimal(amount))
         self.actions[street] += [[player, 'bets', amount]]
 
+    def addFold(self, street, player):
+        self.actions[street] += [[player, 'folds']]
+
+    def addCheck(self, street, player):
+        self.actions[street] += [[player, 'checks']]
+
     def addCollectPot(self,player, pot):
         if player not in self.collected:
             self.collected[player] = pot
@@ -401,7 +407,7 @@ Known bug: doesn't take into account side pots"""
 
         print "*** HOLE CARDS ***"
         if self.involved:
-            print "Dealt to %s [%s %s]" %(self.hero , self.holecards[self.hero][0], self.holecards[self.hero][1])
+            print "Dealt to %s [%s]" %(self.hero , " ".join(self.holecards[self.hero]))
 
         if 'PREFLOP' in self.actions:
             for act in self.actions['PREFLOP']:
@@ -435,18 +441,21 @@ Known bug: doesn't take into account side pots"""
         for s in self.board.values():
             board += s
         if board:   # sometimes hand ends preflop without a board
-            print "Board [%s]" % (board)
+            print "Board [%s]" % (" ".join(board))
         
         #print self.board
         for player in self.players:
-            if player[1] in self.collected and self.holecards[player[1]]:
-                print "Seat %d: %s showed [%s %s] and won ($%s)" % (player[0], player[1], self.holecards[player[1]][0], self.holecards[player[1]][1], self.collected[player[1]])
-            elif player[1] in self.collected:
-                print "Seat %d: %s collected ($%s)" % (player[0], player[1], self.collected[player[1]])
+            seatnum = player[0]
+            name = player[1]
+            if name in self.collected and self.holecards[name]:
+                # TODO: (bug) hero cards will always be 'shown' because they are known to us. Better to explicitly flag those who 'show' their cards.
+                print "Seat %d: %s showed [%s] and won ($%s)" % (seatnum, name, " ".join(self.holecards[name]), self.collected[name])
+            elif name in self.collected:
+                print "Seat %d: %s collected ($%s)" % (seatnum, name, self.collected[name])
             elif self.holecards[player[1]]:
-                print "Seat %d: %s showed [%s %s]" % (player[0], player[1], self.holecards[player[1]][0], self.holecards[player[1]][1])
+                print "Seat %d: %s showed [%s]" % (seatnum, name, " ".join(self.holecards[name]))
             else:
-                print "Seat %d: %s folded (or mucked..)" % (player[0], player[1])
+                print "Seat %d: %s folded or mucked" % (seatnum, name)
             
         print
             # TODO:
@@ -470,6 +479,8 @@ Known bug: doesn't take into account side pots"""
             print "%s: %s " %(act[0], act[1])
         if act[1] == 'calls':
             print "%s: %s $%s" %(act[0], act[1], act[2])
+        if act[1] == 'bets':
+            print "%s: %s $%s" %(act[0], act[1], act[2])
         if act[1] == 'raises':
             print "%s: %s $%s to $%s" %(act[0], act[1], act[2], act[3])
 

From 3ff2ec21063716e2d51452f86999af644c531e96 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Wed, 10 Dec 2008 00:58:10 +0000
Subject: [PATCH 11/12] removed read board cards from markStreets

---
 pyfpdb/EverleafToFpdb.py       | 10 +++++-----
 pyfpdb/HandHistoryConverter.py | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index ff345194..19253ddc 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -118,9 +118,9 @@ class Everleaf(HandHistoryConverter):
     def readPlayerStacks(self, hand):
         m = self.rexx.player_info_re.finditer(hand.string)
         players = []
-        print "\nReading stacks - players seen:"
+        #print "\nReading stacks - players seen:"
         for a in m:
-            print a.group('PNAME')
+            #print a.group('PNAME')
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
@@ -129,9 +129,9 @@ class Everleaf(HandHistoryConverter):
         #m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
 
         m =  re.search(r"\*\* Dealing down cards \*\*(?P<PREFLOP>.+(?=\*\* Dealing Flop \*\*)|.+)"
-                       r"(\*\* Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \](?P<FLOP>.+(?=\*\* Dealing Turn \*\*)|.+))?"
-                       r"(\*\* Dealing Turn \*\* \[ (?P<TURN1>\S\S) \](?P<TURN>.+(?=\*\* Dealing River \*\*)|.+))?"
-                       r"(\*\* Dealing River \*\* \[ (?P<RIVER1>\S\S) \](?P<RIVER>.+))?", hand.string,re.DOTALL)
+                       r"(\*\* Dealing Flop \*\* \[ \S\S, \S\S, \S\S \](?P<FLOP>.+(?=\*\* Dealing Turn \*\*)|.+))?"
+                       r"(\*\* Dealing Turn \*\* \[ \S\S \](?P<TURN>.+(?=\*\* Dealing River \*\*)|.+))?"
+                       r"(\*\* Dealing River \*\* \[ \S\S \](?P<RIVER>.+))?", hand.string,re.DOTALL)
         # that wasn't easy.
 
 
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 5fa83a0e..23f39db3 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -306,7 +306,7 @@ class Hand:
 
     def setCommunityCards(self, street, cards):
         self.board[street] = [self.card(c) for c in cards]
-        print self.board[street]
+        #print self.board[street]
 
     def card(self,c):
         """upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""
@@ -388,7 +388,7 @@ Known bug: doesn't take into account side pots"""
 
     def printHand(self):
         # PokerStars format.
-        print "### Pseudo stars format ###"
+        print "\n### Pseudo stars format ###"
         print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, "XXXXhand.gametype", self.sb, self.bb, self.starttime)
         print "Table '%s' %d-max Seat #%s is the button" %(self.tablename, self.maxseats, self.buttonpos)
         for player in self.players:
@@ -414,17 +414,17 @@ Known bug: doesn't take into account side pots"""
                 self.printActionLine(act)
 
         if 'FLOP' in self.actions:
-            print "*** FLOP *** [%s %s %s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"))
+            print "*** FLOP *** [%s]" %( " ".join(self.board['Flop']))
             for act in self.actions['FLOP']:
                 self.printActionLine(act)
 
         if 'TURN' in self.actions:
-            print "*** TURN *** [%s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"))
+            print "*** TURN *** [%s] [%s]" %( " ".join(self.board['Flop']), " ".join(self.board['Turn']))
             for act in self.actions['TURN']:
                 self.printActionLine(act)
 
         if 'RIVER' in self.actions:
-            print "*** RIVER *** [%s %s %s %s] [%s]" %(self.streets.group("FLOP1"), self.streets.group("FLOP2"), self.streets.group("FLOP3"), self.streets.group("TURN1"), self.streets.group("RIVER1"))
+            print "*** RIVER *** [%s] [%s]" %(" ".join(self.board['Flop']+self.board['Turn']), " ".join(self.board['River']) )
             for act in self.actions['RIVER']:
                 self.printActionLine(act)
                 

From dda88b76ba86e227f8662331af7d9d92e80e84c3 Mon Sep 17 00:00:00 2001
From: Matt Turnbull <mcturnbull@fastmail.fm>
Date: Wed, 10 Dec 2008 16:30:57 +0000
Subject: [PATCH 12/12] cosmetics, comments, some value checking added mucked /
 folded / shown summary lines

---
 pyfpdb/EverleafToFpdb.py       |  25 +----
 pyfpdb/HandHistoryConverter.py | 200 +++++++++++++++++++++------------
 2 files changed, 131 insertions(+), 94 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 19253ddc..7eee20a7 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -68,7 +68,7 @@ class Everleaf(HandHistoryConverter):
         print "Initialising Everleaf converter class"
         HandHistoryConverter.__init__(self, config, file, sitename="Everleaf") # Call super class init.
         self.sitename = "Everleaf"
-        self.setFileType("text")
+        self.setFileType("text", "cp1252")
         self.rexx.setGameInfoRegex('.*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+)')
         self.rexx.setSplitHandRegex('\n\n+')
         self.rexx.setHandInfoRegex('.*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<YEAR>[0-9]+)/(?P<MON>[0-9]+)/(?P<DAY>[0-9]+) - (?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)\nTable (?P<TABLE>[ a-zA-Z]+)\nSeat (?P<BUTTON>[0-9]+)')
@@ -118,9 +118,7 @@ class Everleaf(HandHistoryConverter):
     def readPlayerStacks(self, hand):
         m = self.rexx.player_info_re.finditer(hand.string)
         players = []
-        #print "\nReading stacks - players seen:"
         for a in m:
-            #print a.group('PNAME')
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
@@ -132,28 +130,11 @@ class Everleaf(HandHistoryConverter):
                        r"(\*\* Dealing Flop \*\* \[ \S\S, \S\S, \S\S \](?P<FLOP>.+(?=\*\* Dealing Turn \*\*)|.+))?"
                        r"(\*\* Dealing Turn \*\* \[ \S\S \](?P<TURN>.+(?=\*\* Dealing River \*\*)|.+))?"
                        r"(\*\* Dealing River \*\* \[ \S\S \](?P<RIVER>.+))?", hand.string,re.DOTALL)
-        # that wasn't easy.
 
-
-        #m1 = re.search(r'(\*\* Dealing down cards \*\*)?(?P<PREFLOP>.*?\n\*\*)',hand.string,re.DOTALL)
-        #m2 = re.search(r'(\*\* Dealing Flop \*\*)?(?P<FLOP>.*\n\*\*)',hand.string,re.DOTALL)
-        #print hand.string
-        #print "m  groups:\n",m.groupdict()
-        #print "m1 groups:\n",m1.groupdict()
-        #print "m2 groups:\n",m2.groupdict()
-        #(\*\* Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \](?P<FLOP>.*?)?)?
-        #(\*\* Dealing Turn \*\* \[ (?P<TURN1>\S\S) \](?P<TURN>.*?))?
-        #(\*\* Dealing River \*\* \[ (?P<RIVER1>\S\S) \](?P<RIVER>.*?))?', hand.string,re.DOTALL)
-        
-        
-        #for street in m.groupdict():
-            #print "DEBUG: Street: %s\tspan: %s" %(street, str(m.span(street)))
         hand.streets = m
-        #sys.exit()
 
     def readCommunityCards(self, hand):
         # currently regex in wrong place pls fix my brain's fried
-        # what a mess!
         re_board = re.compile('\*\* Dealing (?P<STREET>.*) \*\* \[ (?P<CARDS>.*) \]')
         m = re_board.finditer(hand.string)
         for street in m:
@@ -209,8 +190,8 @@ class Everleaf(HandHistoryConverter):
             re_card = re.compile('(?P<CARD>[0-9tjqka][schd])')  # copied from earlier
             cards = [card.group('CARD') for card in re_card.finditer(shows.group('CARDS'))]
             print cards
-            hand.addHoleCards(cards, shows.group('PNAME'))
-            
+            hand.addShownCards(cards, shows.group('PNAME'))
+
     def readCollectPot(self,hand):
         m = self.rexx.collect_pot_re.search(hand.string)
         if m is not None:
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 23f39db3..6cb4e2b5 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -23,11 +23,12 @@ import traceback
 import os
 import os.path
 import xml.dom.minidom
+import codecs
 from decimal import Decimal
 import operator
 from xml.dom.minidom import Node
 from pokereval import PokerEval
-
+from time import time
 #from pokerengine.pokercards import *
 # provides letter2name{}, letter2names{}, visible_card(), not_visible_card(), is_visible(), card_value(), class PokerCards
 # but it's probably not installed so here are the ones we may want:
@@ -67,11 +68,11 @@ class HandHistoryConverter:
     eval = PokerEval()
     def __init__(self, config, file, sitename):
         print "HandHistory init called"
-
         self.c         = config
         self.sitename  = sitename
         self.obs       = ""             # One big string
         self.filetype  = "text"
+        self.codepage  = "utf8"
         self.doc       = None     # For XML based HH files
         self.file      = file
         self.hhbase    = self.c.get_import_parameters().get("hhArchiveBase")
@@ -95,6 +96,7 @@ class HandHistoryConverter:
         return tmp
 
     def processFile(self):
+        starttime = time()
         if not self.sanityCheck():
             print "Cowardly refusing to continue after failed sanity check"
             return
@@ -120,7 +122,7 @@ class HandHistoryConverter:
             # finalise it (total the pot)
             hand.totalPot()
             self.getRake(hand)
-            
+
             hand.printHand()
             #if(hand.involved == True):
                 #self.writeHand("output file", hand)
@@ -128,6 +130,9 @@ class HandHistoryConverter:
             #else:
                 #pass #Don't write out observed hands
 
+        endtime = time()
+        print "Processed %d hands in %d seconds" % (len(self.hands), endtime-starttime)
+
     #####
     # These functions are parse actions that may be overridden by the inheriting class
     #
@@ -192,8 +197,9 @@ class HandHistoryConverter:
         return sane
 
     # Functions not necessary to implement in sub class
-    def setFileType(self, filetype = "text"):
+    def setFileType(self, filetype = "text", codepage='utf8'):
         self.filetype = filetype
+        self.codepage = codepage
 
     def splitFileIntoHands(self):
         hands = []
@@ -209,7 +215,7 @@ class HandHistoryConverter:
         """Read file"""
         print "Reading file: '%s'" %(filename)
         if(self.filetype == "text"):
-            infile=open(filename, "rU")
+            infile=codecs.open(filename, "rU", self.codepage)
             self.obs = infile.read()
             infile.close()
         elif(self.filetype == "xml"):
@@ -244,15 +250,14 @@ class Hand:
         self.sitename = sitename
         self.gametype = gametype
         self.string = string
-    
-        self.streets = None # A MatchObject using a groupnames to identify streets.
+
         self.streetList = ['BLINDS','PREFLOP','FLOP','TURN','RIVER'] # a list of the observed street names in order
-        self.actions = {}
-    
+
         self.handid = 0
         self.sb = gametype[3]
         self.bb = gametype[4]
         self.tablename = "Slartibartfast"
+        self.hero = "Hiro"
         self.maxseats = 10
         self.counted_seats = 0
         self.buttonpos = 0
@@ -260,57 +265,104 @@ class Hand:
         self.players = []
         self.posted = []
         self.involved = True
-        
-        self.hero = "Hiro"
-        self.holecards = {} # dict from player names to lists of hole cards
-        self.board = {}     # dict from street names to community cards
-        self.collected = {} # dict from player names to amounts collected
-        
+
+
+        #
+        # Collections indexed by street names
+        #
+
+        # A MatchObject using a groupnames to identify streets.
+        # filled by markStreets()
+        self.streets = None
+
+        # dict from street names to lists of tuples, such as
+        # [['mct','bets','$10'],['mika','folds'],['carlg','raises','$20']]
+        # actually they're clearly lists but they probably should be tuples.
+        self.actions = {}
+
+        # dict from street names to community cards
+        self.board = {}
+
+
+        #
+        # Collections indexed by player names
+        #
+
+        # dict from player names to lists of hole cards
+        self.holecards = {}
+
+        # dict from player names to amounts collected
+        self.collected = {}
+
+        # Sets of players
+        self.shown = set()
+        self.folded = set()
+
         self.action = []
         self.totalpot = None
         self.rake = None
-        
+
         self.bets = {}
         self.lastBet = {}
         for street in self.streetList:
             self.bets[street] = {}
             self.lastBet[street] = 0
-            
+
     def addPlayer(self, seat, name, chips):
-        """seat, an int indicating the seat
-        name, the player name
-        chips, the chips the player has at the start of the hand (can be None)"""
-        self.players.append([seat, name, chips])
-        self.holecards[name] = []
-        #self.startChips[name] = chips
-        #self.endChips[name] = chips
-        #self.winners[name] = 0
-        for street in self.streetList:
-            self.bets[street][name] = []
+        """\
+Adds a player to the hand, and initialises data structures indexed by player.
+seat    (int) indicating the seat
+name    (string) player name
+chips   (string) the chips the player has at the start of the hand (can be None)
+If a player has None chips he won't be added."""
+        if chips is not None:
+            self.players.append([seat, name, chips])
+            self.holecards[name] = []
+            for street in self.streetList:
+                self.bets[street][name] = []
 
 
-    def addHoleCards(self, cards, player=None): # generalise to add hole cards for a specific seat or player
-        for c in cards:
-            self.holecards[player].append(self.card(c))
+    def addHoleCards(self, cards, player):
+        """\
+Assigns observed holecards to a player.
+cards   list of card bigrams e.g. ['2h','jc']
+player  (string) name of player
+Note, will automatically uppercase the rank letter.
+"""
+        try:
+            self.checkPlayerExists(player)
+            for c in cards:
+                self.holecards[player].append(self.card(c))
+        except FpdbParseError, e:
+            print "Tried to add holecards for unknown player: %s" % (player,)
+
+    def addShownCards(self, cards, player):
+        """\
+For when a player shows cards for any reason (for showdown or out of choice).
+"""
+        self.shown.add(player)
+        self.addHoleCards(cards,player)
 
 
-    def discardHoleCards(self, cards, player=None):
-        if seat is None:
-            #raise something
-            pass
-        for card in cards:
-            try:
+    def checkPlayerExists(self,player):
+        if player not in [p[1] for p in self.players]:
+            raise FpdbParseError
+
+    def discardHoleCards(self, cards, player):
+        try:
+            self.checkPlayerExists(player)
+            for card in cards:
                 self.holecards[player].remove(card)
-            except ValueError:
-                print "tried to discard a card player apparently didn't have"
+        except FpdbParseError, e:
+            pass
+        except ValueError:
+            print "tried to discard a card %s didn't have" % (player,)
 
     def setCommunityCards(self, street, cards):
         self.board[street] = [self.card(c) for c in cards]
-        #print self.board[street]
 
     def card(self,c):
         """upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""
-        # don't know how to make this 'static'
         for k,v in self.UPS.items():
             c = c.replace(k,v)
         return c
@@ -321,14 +373,7 @@ class Hand:
             self.bets['PREFLOP'][player].append(Decimal(amount))
         self.lastBet['PREFLOP'] = Decimal(amount)
         self.posted += [player]
-        
 
-    #def addFold(self, street, player=None):
-        ## Called when a player folds.
-        #self.bets[street][player].append(None)
-
-    #def addCheck(self, street, player=None):
-        #self.bets[street][player].append(0)
 
     def addCall(self, street, player=None, amount=None):
         # Potentially calculate the amount of the call if not supplied
@@ -339,11 +384,15 @@ class Hand:
             self.actions[street] += [[player, 'calls', amount]]
         
     def addRaiseTo(self, street, player, amountTo):
-        # Given only the amount raised to, the amount of the raise can be calculated by
+        """\
+Add a raise on [street] by [player] to [amountTo]
+"""
+        #Given only the amount raised to, the amount of the raise can be calculated by
         # working out how much this player has already in the pot 
         #   (which is the sum of self.bets[street][player])
         # and how much he needs to call to match the previous player 
         #   (which is tracked by self.lastBet)
+        self.checkPlayerExists(player)
         committedThisStreet = reduce(operator.add, self.bets[street][player], 0)
         amountToCall = self.lastBet[street] - committedThisStreet
         self.lastBet[street] = Decimal(amountTo)
@@ -351,23 +400,27 @@ class Hand:
         self.bets[street][player].append(amountBy+amountToCall)
         self.actions[street] += [[player, 'raises', amountBy, amountTo]]
         
-    def addBet(self, street, player=None, amount=0):
+    def addBet(self, street, player, amount):
+        self.checkPlayerExists(player)
         self.bets[street][player].append(Decimal(amount))
-        #self.orderedBets[street].append(Decimal(amount))
         self.actions[street] += [[player, 'bets', amount]]
 
     def addFold(self, street, player):
+        self.checkPlayerExists(player)
+        self.folded.add(player)
         self.actions[street] += [[player, 'folds']]
 
     def addCheck(self, street, player):
+        self.checkPlayerExists(player)
         self.actions[street] += [[player, 'checks']]
 
     def addCollectPot(self,player, pot):
+        self.checkPlayerExists(player)
         if player not in self.collected:
             self.collected[player] = pot
         else:
             # possibly lines like "p collected $ from pot" appear during the showdown
-            # but they are usually unique in the summary.
+            # but they are usually unique in the summary, so it's best to try to get them from there.
             print "%s collected pot more than once; avoidable by reading winnings only from summary lines?"
 
 
@@ -376,20 +429,25 @@ class Hand:
 Known bug: doesn't take into account side pots"""
         if self.totalpot is None:
             self.totalpot = 0
-            
+
             # player names: 
             # print [x[1] for x in self.players]
             for player in [x[1] for x in self.players]:
                 for street in self.streetList:
                     #print street, self.bets[street][player]
                     self.totalpot += reduce(operator.add, self.bets[street][player], 0)
-                    
 
+    def getGameTypeAsString(self):
+        """\
+Map the tuple self.gametype onto the pokerstars string describing it
+"""
+        # currently it appears to be something like ["ring", "hold", "nl", sb, bb]:
+        return "Hold'em No Limit"
 
     def printHand(self):
         # PokerStars format.
         print "\n### Pseudo stars format ###"
-        print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, "XXXXhand.gametype", self.sb, self.bb, self.starttime)
+        print "%s Game #%s: %s ($%s/$%s) - %s" %(self.sitename, self.handid, self.getGameTypeAsString(), self.sb, self.bb, self.starttime)
         print "Table '%s' %d-max Seat #%s is the button" %(self.tablename, self.maxseats, self.buttonpos)
         for player in self.players:
             print "Seat %s: %s ($%s)" %(player[0], player[1], player[2])
@@ -402,7 +460,7 @@ Known bug: doesn't take into account side pots"""
         #May be more than 1 bb posting
         for a in self.posted[1:]:
             print "%s: posts big blind $%s" %(self.posted[1], self.bb)
-            
+
         # What about big & small blinds?
 
         print "*** HOLE CARDS ***"
@@ -427,14 +485,15 @@ Known bug: doesn't take into account side pots"""
             print "*** RIVER *** [%s] [%s]" %(" ".join(self.board['Flop']+self.board['Turn']), " ".join(self.board['River']) )
             for act in self.actions['RIVER']:
                 self.printActionLine(act)
-                
-                
+
+
         #Some sites don't have a showdown section so we have to figure out if there should be one
         # The logic for a showdown is: at the end of river action there are at least two players in the hand
+        # we probably don't need a showdown section in pseudo stars format for our filtering purposes
         if 'SHOWDOWN' in self.actions:
             print "*** SHOW DOWN ***"
             print "what do they show"
-        
+
         print "*** SUMMARY ***"
         print "Total pot $%s | Rake $%.2f)" % (self.totalpot, self.rake) # TODO side pots
         board = []
@@ -442,21 +501,22 @@ Known bug: doesn't take into account side pots"""
             board += s
         if board:   # sometimes hand ends preflop without a board
             print "Board [%s]" % (" ".join(board))
-        
-        #print self.board
+
+
         for player in self.players:
             seatnum = player[0]
             name = player[1]
             if name in self.collected and self.holecards[name]:
-                # TODO: (bug) hero cards will always be 'shown' because they are known to us. Better to explicitly flag those who 'show' their cards.
                 print "Seat %d: %s showed [%s] and won ($%s)" % (seatnum, name, " ".join(self.holecards[name]), self.collected[name])
             elif name in self.collected:
                 print "Seat %d: %s collected ($%s)" % (seatnum, name, self.collected[name])
-            elif self.holecards[player[1]]:
+            elif player[1] in self.shown:
                 print "Seat %d: %s showed [%s]" % (seatnum, name, " ".join(self.holecards[name]))
+            elif player[1] in self.folded:
+                print "Seat %d: %s folded" % (seatnum, name)
             else:
-                print "Seat %d: %s folded or mucked" % (seatnum, name)
-            
+                print "Seat %d: %s mucked" % (seatnum, name)
+
         print
             # TODO:
             # logic for side pots
@@ -487,13 +547,6 @@ Known bug: doesn't take into account side pots"""
     # going to use pokereval to figure out hands at some point.
     # these functions are copied from pokergame.py
     def bestHand(self, side, cards):
-        #if self.variant == "omaha" or self.variant == "omaha8":
-        #hand = self.serial2player[serial].hand.tolist(True)
-        #board = self.board.tolist(True)
-        #else:
-        #hand = hand.tolist(True) + board.tolist(True)
-        #board = []
-        print cards
         return HandHistoryConverter.eval.best('hi', cards, [])
 
     # from pokergame.py
@@ -531,4 +584,7 @@ Known bug: doesn't take into account side pots"""
                 return ("Royal flush")
             else:
                 return ("Straight flush %(card)s high") % { 'card' : (letter2name[cards[0][0]]) }
-        return value
\ No newline at end of file
+        return value
+        
+        
+class FpdbParseError(Exception): pass
\ No newline at end of file