diff --git a/pyfpdb/CliFpdb.py b/pyfpdb/CliFpdb.py
old mode 100755
new mode 100644
diff --git a/pyfpdb/Configuration.py b/pyfpdb/Configuration.py
old mode 100755
new mode 100644
diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
old mode 100644
new mode 100755
index b9df28e2..1a1196c5
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -58,42 +58,46 @@ 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):
-	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 \[')
-		self.rexx.setPostBbRegex('.*\n(?P<PNAME>.*): posts big blind \[')
-		self.rexx.setHeroCardsRegex('.*\nDealt\sto\s(?P<PNAME>.*)\s\[ (?P<HOLECARDS>.*) \]')
-		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, sitename="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.setShowdownActionRegex('.*\n(?P<PNAME>.*) shows \[ (?P<CARDS>.*) \]')
+        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')
@@ -106,66 +110,87 @@ 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:
-			players = players + [[a.group('SEAT'), a.group('PNAME'), a.group('CASH')]]
+        for a in m:
+            hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
-		hand.players = players
-
-	def markStreets(self, hand):
-		# PREFLOP = ** Dealing down cards **
-		m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\*)?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\*)?(?P<TURN>.*?\*\*)?( Dealing River \*\*)?(?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.posted = [m.group('PNAME')]
-		except:
-			hand.posted = ["FpdbNBP"]
-		m = self.rexx.big_blind_re.finditer(hand.string)
-		for a in m:
-			hand.posted = hand.posted + [a.group('PNAME')]
+    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 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.holecards = m.group('HOLECARDS')
-			hand.holecards = hand.holecards.replace(',','')
-			#Must be a better way to do the following tr akqjt AKQJT
-			hand.holecards = hand.holecards.replace('a','A')
-			hand.holecards = hand.holecards.replace('k','K')
-			hand.holecards = hand.holecards.replace('q','Q')
-			hand.holecards = hand.holecards.replace('j','J')
-			hand.holecards = hand.holecards.replace('t','T')
+    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 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' or action.group('ATYPE') == 'calls':
-				hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE'), action.group('BET')]]
-			else:
-				hand.actions[street] += [[action.group('PNAME'), action.group('ATYPE')]]
-		print "DEBUG: readAction: %s " %(hand.actions)
+    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')], m.group('PNAME'))
 
+    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 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
 
 if __name__ == "__main__":
-	c = Configuration.Config()
-	e = Everleaf(c, "regression-test-files/everleaf/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/FpdbSQLQueries.py b/pyfpdb/FpdbSQLQueries.py
index 11826018..a3d918ac 100644
--- a/pyfpdb/FpdbSQLQueries.py
+++ b/pyfpdb/FpdbSQLQueries.py
@@ -576,26 +576,23 @@ class FpdbSQLQueries:
         if(self.dbname == 'MySQL InnoDB'):
             self.query['addTourneyIndex'] = """ALTER TABLE Tourneys ADD INDEX siteTourneyNo(siteTourneyNo)"""
         elif(self.dbname == 'PostgreSQL'):
-            # FIXME: This query has a different syntax
-            self.query['addTourneyIndex'] = """ALTER TABLE Tourneys ADD INDEX siteTourneyNo(siteTourneyNo)"""
+            self.query['addTourneyIndex'] = """CREATE INDEX siteTourneyNo ON Tourneys (siteTourneyNo)"""
         elif(self.dbname == 'SQLite'):
             self.query['addHandsIndex'] = """ """
 
         if(self.dbname == 'MySQL InnoDB'):
             self.query['addHandsIndex'] = """ALTER TABLE Hands ADD INDEX siteHandNo(siteHandNo)"""
         elif(self.dbname == 'PostgreSQL'):
-            # FIXME: This query has a different syntax
-            self.query['addHandsIndex'] = """ALTER TABLE Hands ADD INDEX siteHandNo(siteHandNo)"""
+            self.query['addHandsIndex'] = """CREATE INDEX siteHandNo ON Hands (siteHandNo)"""
         elif(self.dbname == 'SQLite'):
             self.query['addHandsIndex'] = """ """
 
         if(self.dbname == 'MySQL InnoDB'):
             self.query['addPlayersIndex'] = """ALTER TABLE Players ADD INDEX name(name)"""
         elif(self.dbname == 'PostgreSQL'):
-            # FIXME: This query has a different syntax
-            self.query['addHandsIndex'] = """ALTER TABLE Hands ADD INDEX siteHandNo(siteHandNo)"""
+            self.query['addPlayersIndex'] = """CREATE INDEX name ON Players (name)"""
         elif(self.dbname == 'SQLite'):
-            self.query['addHandsIndex'] = """ """
+            self.query['addPlayersIndex'] = """ """
 
     	################################
     	# Queries used in GuiGraphViewer
@@ -633,6 +630,11 @@ class FpdbSQLQueries:
     				WHERE Players.name = %s AND HandsPlayers.handId = %s 
     				AND Players.siteId = %s AND (tourneysPlayersId IS NULL)"""
 
+    	if(self.dbname == 'MySQL InnoDB') or (self.dbname == 'PostgreSQL'):
+    		self.query['getPlayerId'] = """SELECT id from Players where name = %s"""
+    	elif(self.dbname == 'SQLite'):
+    		self.query['getPlayerId'] = """SELECT id from Players where name = %s"""
+
     	if(self.dbname == 'MySQL InnoDB') or (self.dbname == 'PostgreSQL'):
     		self.query['getRingProfitAllHandsPlayerIdSite'] = """
     			SELECT hp.handId, hp.winnings, SUM(ha.amount), hp.winnings - SUM(ha.amount)
@@ -697,13 +699,11 @@ class FpdbSQLQueries:
                            ,round(100*sum(street2Aggr)/sum(street2Seen)) AS TuAFq
                            ,round(100*sum(street3Aggr)/sum(street3Seen)) AS RvAFq
                            ,round(100*(sum(street1Aggr)+sum(street2Aggr)+sum(street3Aggr))
-
                 /(sum(street1Seen)+sum(street2Seen)+sum(street3Seen))) AS PFAFq
                      from Gametypes gt
                           inner join Sites s on s.Id = gt.siteId
                           inner join HudCache hc on hc.gameTypeId = gt.Id
-                     where gt.limittype = 'nl'
-                     and   hc.playerId in (3)   # use <player_test> here?
+                     where hc.playerId in <player_test>
                                                 # use <gametype_test> here ?
                      group by hc.gametypeId
                     ) stats
@@ -716,7 +716,7 @@ class FpdbSQLQueries:
                           from HandsPlayers hp
                           inner join Hands h         ON h.id            = hp.handId
                           inner join HandsActions ha ON ha.handPlayerId = hp.id
-                          where hp.playerId in (3)   # use <player_test> here?
+                          where hp.playerId in <player_test>
                                                      # use <gametype_test> here ?
                           and   hp.tourneysPlayersId IS NULL
                           group by hp.handId, h.gameTypeId, hp.position, hp.winnings
diff --git a/pyfpdb/GuiGraphViewer.py b/pyfpdb/GuiGraphViewer.py
index 5b83775a..d50f6b6a 100644
--- a/pyfpdb/GuiGraphViewer.py
+++ b/pyfpdb/GuiGraphViewer.py
@@ -24,289 +24,300 @@ from time import time
 #import pokereval
 
 try:
-	import matplotlib
-	matplotlib.use('GTK')
-	from matplotlib.figure import Figure
-	from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
-	from matplotlib.backends.backend_gtkagg import NavigationToolbar2GTKAgg as NavigationToolbar
-	from numpy import arange, cumsum
-	from pylab import *
+    import matplotlib
+    matplotlib.use('GTK')
+    from matplotlib.figure import Figure
+    from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
+    from matplotlib.backends.backend_gtkagg import NavigationToolbar2GTKAgg as NavigationToolbar
+    from numpy import arange, cumsum
+    from pylab import *
 except:
-	print """Failed to load libs for graphing, graphing will not function. Please in
+    print """Failed to load libs for graphing, graphing will not function. Please in
                  stall numpy and matplotlib if you want to use graphs."""
-	print """This is of no consequence for other parts of the program, e.g. import 
-		 and HUD are NOT affected by this problem."""
+    print """This is of no consequence for other parts of the program, e.g. import 
+         and HUD are NOT affected by this problem."""
 
 import fpdb_import
 import fpdb_db
 
 class GuiGraphViewer (threading.Thread):
-	def get_vbox(self):
-		"""returns the vbox of this thread"""
-		return self.mainHBox
-	#end def get_vbox
-	
-	def generateGraph(self, widget, data):
-		try: self.canvas.destroy()
-		except AttributeError: pass
+    def get_vbox(self):
+        """returns the vbox of this thread"""
+        return self.mainHBox
+    #end def get_vbox
 
-		# Whaich sites are selected?
-		# TODO:
-		# What hero names for the selected site?
-		# TODO:
+    def generateGraph(self, widget, data):
+        try: self.canvas.destroy()
+        except AttributeError: pass
 
-		name = self.heroes[self.sites]
-		
-		if self.sites == "PokerStars":
-			site=2
-			sitename="PokerStars: "
-		elif self.sites=="Full Tilt":
-			site=1
-			sitename="Full Tilt: "
-		else:
-			print "invalid text in site selection in graph, defaulting to PS"
-			site=2
-		
-		self.fig = Figure(figsize=(5,4), dpi=100)
+        # Whaich sites are selected?
+        # TODO:
+        # What hero names for the selected site?
+        # TODO:
 
-		#Set graph properties
-		self.ax = self.fig.add_subplot(111)
+        name = self.heroes[self.sites]
 
-		#Get graph data from DB
-		starttime = time()
-		line = self.getRingProfitGraph(name, site)
-		print "Graph generated in: %s" %(time() - starttime)
+        if self.sites == "PokerStars":
+            site=2
+            sitename="PokerStars: "
+        elif self.sites=="Full Tilt":
+            site=1
+            sitename="Full Tilt: "
+        else:
+            print "invalid text in site selection in graph, defaulting to PS"
+            site=2
 
-		self.ax.set_title("Profit graph for ring games")
+        self.fig = Figure(figsize=(5,4), dpi=100)
 
-		#Set axis labels and grid overlay properites
-		self.ax.set_xlabel("Hands", fontsize = 12)
-		self.ax.set_ylabel("$", fontsize = 12)
-		self.ax.grid(color='g', linestyle=':', linewidth=0.2)
-		text = "All Hands, " + sitename + str(name) + "\nProfit: $" + str(line[-1]) + "\nTotal Hands: " + str(len(line))
+        #Set graph properties
+        self.ax = self.fig.add_subplot(111)
 
-		self.ax.annotate(text, xy=(10, -10),
-                xycoords='axes points',
-                horizontalalignment='left', verticalalignment='top',
-                fontsize=10)
+        #Get graph data from DB
+        starttime = time()
+        line = self.getRingProfitGraph(name, site)
+        print "Graph generated in: %s" %(time() - starttime)
+
+        self.ax.set_title("Profit graph for ring games")
+
+        #Set axis labels and grid overlay properites
+        self.ax.set_xlabel("Hands", fontsize = 12)
+        self.ax.set_ylabel("$", fontsize = 12)
+        self.ax.grid(color='g', linestyle=':', linewidth=0.2)
+        #This line will crash if no hands exist in the query.
+        text = "All Hands, " + sitename + str(name) + "\nProfit: $" + str(line[-1]) + "\nTotal Hands: " + str(len(line))
+
+        self.ax.annotate(text, 
+                        xy=(10, -10),
+                        xycoords='axes points',
+                        horizontalalignment='left', verticalalignment='top',
+                        fontsize=10)
 
 
-		#Draw plot
-		self.ax.plot(line,)
+        #Draw plot
+        self.ax.plot(line,)
 
-		self.canvas = FigureCanvas(self.fig)  # a gtk.DrawingArea
-		self.graphBox.add(self.canvas)
-		self.canvas.show()
-	#end of def showClicked
+        self.canvas = FigureCanvas(self.fig)  # a gtk.DrawingArea
+        self.graphBox.add(self.canvas)
+        self.canvas.show()
+    #end of def showClicked
 
-	def getRingProfitGraph(self, name, site):
-		self.cursor.execute(self.sql.query['getRingProfitAllHandsPlayerIdSite'], (name, site))
-		#       returns (HandId,Winnings,Costs,Profit)
-                winnings = self.db.cursor.fetchall()
+    def getRingProfitGraph(self, name, site):
+        self.cursor.execute(self.sql.query['getRingProfitAllHandsPlayerIdSite'], (name, site))
+        #returns (HandId,Winnings,Costs,Profit)
+        winnings = self.db.cursor.fetchall()
 
-                y=map(lambda x:float(x[3]), winnings)
-                line = cumsum(y)
-                return line/100
+        y=map(lambda x:float(x[3]), winnings)
+        line = cumsum(y)
+        return line/100
         #end of def getRingProfitGraph
 
-	def createPlayerLine(self, hbox, site, player):
-		label = gtk.Label(site +" id:")
-		hbox.pack_start(label, False, False, 0)
-		label.show()
+    def createPlayerLine(self, hbox, site, player):
+        label = gtk.Label(site +" id:")
+        hbox.pack_start(label, False, False, 0)
+        label.show()
 
-		pname = gtk.Entry()
-		pname.set_text(player)
-		pname.set_width_chars(20)
-		hbox.pack_start(pname, False, True, 0)
-		#TODO: Need to connect a callback here
-		pname.connect("changed", self.__set_hero_name, site)
-		#TODO: Look at GtkCompletion - to fill out usernames
-		pname.show()
+        pname = gtk.Entry()
+        pname.set_text(player)
+        pname.set_width_chars(20)
+        hbox.pack_start(pname, False, True, 0)
+        #TODO: Need to connect a callback here
+        pname.connect("changed", self.__set_hero_name, site)
+        #TODO: Look at GtkCompletion - to fill out usernames
+        pname.show()
 
-		self.__set_hero_name(pname, site)
+        self.__set_hero_name(pname, site)
 
-	def __set_hero_name(self, w, site):
-		self.heroes[site] = w.get_text()
-		print "DEBUG: settings heroes[%s]: %s"%(site, self.heroes[site])
+    def __set_hero_name(self, w, site):
+        self.heroes[site] = w.get_text()
+        print "DEBUG: settings heroes[%s]: %s"%(site, self.heroes[site])
 
-	def createSiteLine(self, hbox, site):
-                cb = gtk.CheckButton(site)
-		cb.connect('clicked', self.__set_site_select, site)
-		hbox.pack_start(cb, False, False, 0)
-                cb.show()
+    def createSiteLine(self, hbox, site):
+        cb = gtk.CheckButton(site)
+        cb.connect('clicked', self.__set_site_select, site)
+        hbox.pack_start(cb, False, False, 0)
+        cb.show()
 
-	def __set_site_select(self, w, site):
-		# This doesn't behave as intended - self.site only allows 1 site for the moment.
-		self.sites = site
-		print "self.sites set to %s" %(self.sites)
+    def __set_site_select(self, w, site):
+        # This doesn't behave as intended - self.site only allows 1 site for the moment.
+        self.sites = site
+        print "self.sites set to %s" %(self.sites)
 
-	def fillPlayerFrame(self, vbox):
-		for site in self.conf.supported_sites.keys():
-			pathHBox = gtk.HBox(False, 0)
-			vbox.pack_start(pathHBox, False, True, 0)
-			pathHBox.show()
+    def fillPlayerFrame(self, vbox):
+        for site in self.conf.supported_sites.keys():
+            pathHBox = gtk.HBox(False, 0)
+            vbox.pack_start(pathHBox, False, True, 0)
+            pathHBox.show()
 
-			player = self.conf.supported_sites[site].screen_name
-			self.createPlayerLine(pathHBox, site, player)
+            player = self.conf.supported_sites[site].screen_name
+            self.createPlayerLine(pathHBox, site, player)
 
-	def fillSitesFrame(self, vbox):
-		for site in self.conf.supported_sites.keys():
-                        hbox = gtk.HBox(False, 0)
-                        vbox.pack_start(hbox, False, True, 0)
-                        hbox.show()
-			self.createSiteLine(hbox, site)
+    def fillSitesFrame(self, vbox):
+        for site in self.conf.supported_sites.keys():
+            hbox = gtk.HBox(False, 0)
+            vbox.pack_start(hbox, False, True, 0)
+            hbox.show()
+            self.createSiteLine(hbox, site)
 
-	def fillDateFrame(self, vbox):
-		# Hat tip to Mika Bostrom - calendar code comes from PokerStats
-		hbox = gtk.HBox()
-		vbox.pack_start(hbox, False, True, 0)
-		hbox.show()
+    def fillDateFrame(self, vbox):
+        # Hat tip to Mika Bostrom - calendar code comes from PokerStats
+        hbox = gtk.HBox()
+        vbox.pack_start(hbox, False, True, 0)
+        hbox.show()
 
-		lbl_start = gtk.Label('From:')
-		lbl_start.show()
+        lbl_start = gtk.Label('From:')
+        lbl_start.show()
 
-		btn_start = gtk.Button()
-		btn_start.set_image(gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
-		btn_start.connect('clicked', self.__calendar_dialog, self.start_date)
-		btn_start.show()
+        btn_start = gtk.Button()
+        btn_start.set_image(gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
+        btn_start.connect('clicked', self.__calendar_dialog, self.start_date)
+        btn_start.show()
 
-		hbox.pack_start(lbl_start, expand=False, padding=3)
-		hbox.pack_start(btn_start, expand=False, padding=3)
-		hbox.pack_start(self.start_date, expand=False, padding=2)
-		self.start_date.show()
+        hbox.pack_start(lbl_start, expand=False, padding=3)
+        hbox.pack_start(btn_start, expand=False, padding=3)
+        hbox.pack_start(self.start_date, expand=False, padding=2)
+        self.start_date.show()
 
-		#New row for end date
-		hbox = gtk.HBox()
-		vbox.pack_start(hbox, False, True, 0)
-		hbox.show()
+        #New row for end date
+        hbox = gtk.HBox()
+        vbox.pack_start(hbox, False, True, 0)
+        hbox.show()
 
-	        lbl_end = gtk.Label('  To:')
-		lbl_end.show()
-		btn_end = gtk.Button()
-		btn_end.set_image(gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
-		btn_end.connect('clicked', self.__calendar_dialog, self.end_date)
-		btn_end.show()
+        lbl_end = gtk.Label('  To:')
+        lbl_end.show()
+        btn_end = gtk.Button()
+        btn_end.set_image(gtk.image_new_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON))
+        btn_end.connect('clicked', self.__calendar_dialog, self.end_date)
+        btn_end.show()
 
-		btn_clear = gtk.Button(label=' Clear Dates ')
-		btn_clear.connect('clicked', self.__clear_dates)
-		btn_clear.show()
+        btn_clear = gtk.Button(label=' Clear Dates ')
+        btn_clear.connect('clicked', self.__clear_dates)
+        btn_clear.show()
 
-		hbox.pack_start(lbl_end, expand=False, padding=3)
-		hbox.pack_start(btn_end, expand=False, padding=3)
-		hbox.pack_start(self.end_date, expand=False, padding=2)
-		self.end_date.show()
+        hbox.pack_start(lbl_end, expand=False, padding=3)
+        hbox.pack_start(btn_end, expand=False, padding=3)
+        hbox.pack_start(self.end_date, expand=False, padding=2)
+        self.end_date.show()
 
-		hbox.pack_start(btn_clear, expand=False, padding=15)
+        hbox.pack_start(btn_clear, expand=False, padding=15)
 
-	def __calendar_dialog(self, widget, entry):
-		d = gtk.Window(gtk.WINDOW_TOPLEVEL)
-		d.set_title('Pick a date')
+    def __calendar_dialog(self, widget, entry):
+        d = gtk.Window(gtk.WINDOW_TOPLEVEL)
+        d.set_title('Pick a date')
 
-		vb = gtk.VBox()
-		cal = gtk.Calendar()
-		vb.pack_start(cal, expand=False, padding=0)
+        vb = gtk.VBox()
+        cal = gtk.Calendar()
+        vb.pack_start(cal, expand=False, padding=0)
 
-		btn = gtk.Button('Done')
-		btn.connect('clicked', self.__get_date, cal, entry, d)
+        btn = gtk.Button('Done')
+        btn.connect('clicked', self.__get_date, cal, entry, d)
 
-		vb.pack_start(btn, expand=False, padding=4)
+        vb.pack_start(btn, expand=False, padding=4)
 
-		d.add(vb)
-		d.set_position(gtk.WIN_POS_MOUSE)
-		d.show_all()
+        d.add(vb)
+        d.set_position(gtk.WIN_POS_MOUSE)
+        d.show_all()
 
-	def __clear_dates(self, w):
-		self.start_date.set_text('')
-		self.end_date.set_text('')
+    def __clear_dates(self, w):
+        self.start_date.set_text('')
+        self.end_date.set_text('')
 
-	def __get_dates(self):
-		t1 = self.start_date.get_text()
-		t2 = self.end_date.get_text()
-		return (t1, t2)
+    def __get_dates(self):
+        t1 = self.start_date.get_text()
+        t2 = self.end_date.get_text()
+        return (t1, t2)
 
-	def __get_date(self, widget, calendar, entry, win):
+    def __get_date(self, widget, calendar, entry, win):
 # year and day are correct, month is 0..11
-		(year, month, day) = calendar.get_date()
-		month += 1
-		ds = '%04d-%02d-%02d' % (year, month, day)
-		entry.set_text(ds)
-		win.destroy()
+        (year, month, day) = calendar.get_date()
+        month += 1
+        ds = '%04d-%02d-%02d' % (year, month, day)
+        entry.set_text(ds)
+        win.destroy()
 
-	def __init__(self, db, settings, querylist, config, debug=True):
-		"""Constructor for GraphViewer"""
-		self.debug=debug
-		#print "start of GraphViewer constructor"
-		self.db=db
-		self.cursor=db.cursor
-		self.settings=settings
-		self.sql=querylist
-		self.conf = config
+    def exportGraph (self, widget, data):
+        dia_chooser = gtk.FileChooserDialog(title="Please choose the directory you wish to export to:",
+                                            action=gtk.FILE_CHOOSER_ACTION_OPEN,
+                                            buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
 
-		self.sites = "PokerStars"
-		self.heroes = {}
+        response = dia_chooser.run()
+        if response == gtk.RESPONSE_OK:
+            self.exportDir = dia_chooser.get_filename()
+        elif response == gtk.RESPONSE_CANCEL:
+            print 'Closed, no graph exported'
+        dia_chooser.destroy()
 
-		# For use in date ranges.
-		self.start_date = gtk.Entry(max=12)
-		self.end_date = gtk.Entry(max=12)
-		self.start_date.set_property('editable', False)
-		self.end_date.set_property('editable', False)
+    def __init__(self, db, settings, querylist, config, debug=True):
+        """Constructor for GraphViewer"""
+        self.debug=debug
+        #print "start of GraphViewer constructor"
+        self.db=db
+        self.cursor=db.cursor
+        self.settings=settings
+        self.sql=querylist
+        self.conf = config
+
+        self.sites = "PokerStars"
+        self.heroes = {}
+
+        # For use in date ranges.
+        self.start_date = gtk.Entry(max=12)
+        self.end_date = gtk.Entry(max=12)
+        self.start_date.set_property('editable', False)
+        self.end_date.set_property('editable', False)
         
-		self.mainHBox = gtk.HBox(False, 0)
-                self.mainHBox.show()
+        self.mainHBox = gtk.HBox(False, 0)
+        self.mainHBox.show()
 
-		self.leftPanelBox = gtk.VBox(False, 0)
-                self.graphBox = gtk.VBox(False, 0)
+        self.leftPanelBox = gtk.VBox(False, 0)
+        self.graphBox = gtk.VBox(False, 0)
 
-		self.hpane = gtk.HPaned()
-		self.hpane.pack1(self.leftPanelBox)
-		self.hpane.pack2(self.graphBox)
-		self.hpane.show()
+        self.hpane = gtk.HPaned()
+        self.hpane.pack1(self.leftPanelBox)
+        self.hpane.pack2(self.graphBox)
+        self.hpane.show()
 
-		self.mainHBox.add(self.hpane)
+        self.mainHBox.add(self.hpane)
 
-		playerFrame = gtk.Frame("Hero:")
-                playerFrame.set_label_align(0.0, 0.0)
-                playerFrame.show()
-                vbox = gtk.VBox(False, 0)
-                vbox.show()
+        playerFrame = gtk.Frame("Hero:")
+        playerFrame.set_label_align(0.0, 0.0)
+        playerFrame.show()
+        vbox = gtk.VBox(False, 0)
+        vbox.show()
 
-		self.fillPlayerFrame(vbox)
-                playerFrame.add(vbox)
+        self.fillPlayerFrame(vbox)
+        playerFrame.add(vbox)
 
-                sitesFrame = gtk.Frame("Sites:")
-                sitesFrame.set_label_align(0.0, 0.0)
-                sitesFrame.show()
-                vbox = gtk.VBox(False, 0)
-                vbox.show()
+        sitesFrame = gtk.Frame("Sites:")
+        sitesFrame.set_label_align(0.0, 0.0)
+        sitesFrame.show()
+        vbox = gtk.VBox(False, 0)
+        vbox.show()
 
-		self.fillSitesFrame(vbox)
-                sitesFrame.add(vbox)
+        self.fillSitesFrame(vbox)
+        sitesFrame.add(vbox)
 
-                dateFrame = gtk.Frame("Date:")
-                dateFrame.set_label_align(0.0, 0.0)
-                dateFrame.show()
-                vbox = gtk.VBox(False, 0)
-                vbox.show()
+        dateFrame = gtk.Frame("Date:")
+        dateFrame.set_label_align(0.0, 0.0)
+        dateFrame.show()
+        vbox = gtk.VBox(False, 0)
+        vbox.show()
 
-		self.fillDateFrame(vbox)
-                dateFrame.add(vbox)
+        self.fillDateFrame(vbox)
+        dateFrame.add(vbox)
 
-                graphButton=gtk.Button("Generate Graph")
-                graphButton.connect("clicked", self.generateGraph, "cliced data")
-                graphButton.show()
+        graphButton=gtk.Button("Generate Graph")
+        graphButton.connect("clicked", self.generateGraph, "cliced data")
+        graphButton.show()
 
-                self.exportButton=gtk.Button("Export to File")
-#@              self.exportButton.connect("clicked", self.exportGraph, "show clicked")
-                self.exportButton.show()
+        self.exportButton=gtk.Button("Export to File")
+        self.exportButton.connect("clicked", self.exportGraph, "show clicked")
+        self.exportButton.show()
 
-                self.leftPanelBox.add(playerFrame)
-                self.leftPanelBox.add(sitesFrame)
-                self.leftPanelBox.add(dateFrame)
-                self.leftPanelBox.add(graphButton)
-                self.leftPanelBox.add(self.exportButton)
+        self.leftPanelBox.add(playerFrame)
+        self.leftPanelBox.add(sitesFrame)
+        self.leftPanelBox.add(dateFrame)
+        self.leftPanelBox.add(graphButton)
+        self.leftPanelBox.add(self.exportButton)
 
-                self.leftPanelBox.show()
-                self.graphBox.show()	
-	
-		#Note: Assumes PokerStars is in the config
-	#	self.nameEntry.set_text(self.conf.supported_sites["PokerStars"].screen_name)
+        self.leftPanelBox.show()
+        self.graphBox.show()
diff --git a/pyfpdb/GuiPlayerStats.py b/pyfpdb/GuiPlayerStats.py
new file mode 100644
index 00000000..7d689228
--- /dev/null
+++ b/pyfpdb/GuiPlayerStats.py
@@ -0,0 +1,165 @@
+#!/usr/bin/python
+
+#Copyright 2008 Steffen Jobbagy-Felso
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU Affero General Public License as published by
+#the Free Software Foundation, version 3 of the License.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU Affero General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+#In the "official" distribution you can find the license in
+#agpl-3.0.txt in the docs folder of the package.
+
+import threading
+import pygtk
+pygtk.require('2.0')
+import gtk
+import os
+    
+import fpdb_import
+import fpdb_db
+import FpdbSQLQueries
+
+class GuiPlayerStats (threading.Thread):
+    def get_vbox(self):
+        """returns the vbox of this thread"""
+        return self.main_hbox
+
+    def toggleCallback(self, widget, data=None):
+#        print "%s was toggled %s" % (data, ("OFF", "ON")[widget.get_active()])
+        self.activesite = data
+        print "DEBUG: activesite set to %s" %(self.activesite)
+
+    def refreshStats(self, widget, data):
+        try: self.stats_table.destroy()
+        except AttributeError: pass
+        self.fillStatsFrame(self.stats_frame)
+
+    def fillStatsFrame(self, vbox):
+        # Get currently active site and grab playerid
+        tmp = self.sql.query['playerStats']
+
+        result = self.cursor.execute(self.sql.query['getPlayerId'], self.heroes[self.activesite])
+        result = self.db.cursor.fetchall()
+        pid = result[0][0]
+        tmp = tmp.replace("<player_test>", "(" + str(pid) + ")")
+        self.cursor.execute(tmp)
+        result = self.db.cursor.fetchall()
+        cols = 18
+        rows = len(result)+1 # +1 for title row
+        self.stats_table = gtk.Table(rows, cols, False)
+        self.stats_table.set_col_spacings(4)
+        self.stats_table.show()
+        vbox.add(self.stats_table)
+
+        # Create header row
+        titles = ("GID", "base", "Style", "Site", "$BB", "Hands", "VPIP", "PFR", "saw_f", "sawsd", "wtsdwsf", "wmsd", "FlAFq", "TuAFq", "RvAFq", "PFAFq", "Net($)", "BB/100")
+
+        col = 0
+        row = 0
+        for t in titles:
+            l = gtk.Label(titles[col])
+            l.show()
+            self.stats_table.attach(l, col, col+1, row, row+1)
+            col +=1 
+
+        for row in range(rows-1):
+            for col in range(cols):
+                if(row%2 == 0):
+                    bgcolor = "white"
+                else:
+                    bgcolor = "lightgrey"
+                eb = gtk.EventBox()
+                eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(bgcolor))
+                l = gtk.Label(result[row-1][col])
+                eb.add(l)
+                self.stats_table.attach(eb, col, col+1, row+1, row+2)
+                l.show()
+                eb.show()
+
+
+    def fillPlayerFrame(self, vbox):
+        for site in self.conf.supported_sites.keys():
+            hbox = gtk.HBox(False, 0)
+            vbox.pack_start(hbox, False, True, 0)
+            hbox.show()
+
+            player = self.conf.supported_sites[site].screen_name
+            self.createPlayerLine(hbox, site, player)
+        hbox = gtk.HBox(False, 0)
+        button = gtk.Button("Refresh")
+        button.connect("clicked", self.refreshStats, False)
+        button.show()
+        hbox.add(button)
+        vbox.pack_start(hbox, False, True, 0)
+        hbox.show()
+
+    def createPlayerLine(self, hbox, site, player):
+        if(self.buttongroup == None):
+            button = gtk.RadioButton(None, site + " id:")
+            button.set_active(True)
+            self.buttongroup = button
+            self.activesite = site
+        else:
+            button = gtk.RadioButton(self.buttongroup, site + " id:")
+        hbox.pack_start(button, True, True, 0)
+        button.connect("toggled", self.toggleCallback, site)
+        button.show()
+
+        pname = gtk.Entry()
+        pname.set_text(player)
+        pname.set_width_chars(20)
+        hbox.pack_start(pname, False, True, 0)
+        pname.connect("changed", self.__set_hero_name, site)
+        #TODO: Look at GtkCompletion - to fill out usernames
+        pname.show()
+        self.__set_hero_name(pname, site)
+
+    def __set_hero_name(self, w, site):
+        self.heroes[site] = w.get_text()
+        print "DEBUG: settings heroes[%s]: %s"%(site, self.heroes[site])
+    
+    def __init__(self, db, config, querylist, debug=True):
+        self.debug=debug
+        self.db=db
+        self.cursor=db.cursor
+        self.conf=config
+
+        self.sql = querylist
+
+        self.activesite = None
+        self.buttongroup = None
+
+        self.heroes = {}
+        self.stat_table = None
+        self.stats_frame = None
+        
+        self.main_hbox = gtk.HBox(False, 0)
+        self.main_hbox.show()
+
+        playerFrame = gtk.Frame("Hero:")
+        playerFrame.set_label_align(0.0, 0.0)
+        playerFrame.show()
+        vbox = gtk.VBox(False, 0)
+        vbox.show()
+
+        self.fillPlayerFrame(vbox)
+        playerFrame.add(vbox)
+
+        statsFrame = gtk.Frame("Stats:")
+        statsFrame.set_label_align(0.0, 0.0)
+        statsFrame.show()
+        self.stats_frame = gtk.VBox(False, 0)
+        self.stats_frame.show()
+
+        self.fillStatsFrame(self.stats_frame)
+        statsFrame.add(self.stats_frame)
+
+        self.main_hbox.pack_start(playerFrame)
+        self.main_hbox.pack_start(statsFrame)
+
diff --git a/pyfpdb/HUD_main.py b/pyfpdb/HUD_main.py
old mode 100755
new mode 100644
index ffa307d0..0251c7cf
--- a/pyfpdb/HUD_main.py
+++ b/pyfpdb/HUD_main.py
@@ -169,4 +169,3 @@ if __name__== "__main__":
     main_window.show_all()
     
     gtk.main()
-
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 3050b39e..06a59064 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -23,254 +23,492 @@ import traceback
 import os
 import os.path
 import xml.dom.minidom
+from decimal import Decimal
+import operator
 from xml.dom.minidom import Node
+from pokereval import PokerEval
 
 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  = []
-#		self.ofile     = os.path.join(self.hhdir,file)
-		self.rexx      = FpdbRegex.FpdbRegex()
+    eval = PokerEval()
+    def __init__(self, config, file, sitename):
+        print "HandHistory init called"
 
-	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)
+        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()
+
+    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) # 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)
 
-			# 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
 
-			if(hand.involved == True):
-				self.writeHand("output file", hand)
-			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
 
-	# Functions to be implemented in 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
 
-	#TODO: Comment
-	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
-	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
+        return sane
 
-	def sanityCheck(self):
-		sane = False
-		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"
+    # Functions not necessary to implement in sub class
+    def setFileType(self, filetype = "text"):
+        self.filetype = filetype
 
-		return sane
-
-	# 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]" %(hand.hero ,hand.holecards)
-#
-##		ACTION STUFF
-#		This is no limit only at the moment
-		
-		for act in hand.actions['PREFLOP']:
-			self.printActionLine(act, 0)
+        print "*** HOLE CARDS ***"
+        print "Dealt to %s [%s %s]" %(hand.hero , hand.holecards[0], hand.holecards[1])
 
-		if 'FLOP' in hand.actions:
-			print "*** FLOP *** [%s]" %("XXXXX Flop cards XXXXXX")
-			for act in hand.actions['FLOP']:
-				self.printActionLine(act, 0)
+        for act in hand.actions['PREFLOP']:
+            self.printActionLine(act, 0)
 
-		if 'TURN' in hand.actions:
-			print "*** TURN *** [%s] [%s]" %("XXXXX Flop cards XXXXXX", "XXXXX Turn Card XXXXX")
-			for act in hand.actions['TURN']:
-				self.printActionLine(act, 0)
+        if 'PREFLOP' in hand.actions:
+            for act in hand.actions['PREFLOP']:
+                print "PF action"
 
-		if 'RIVER' in hand.actions:
-			print "*** RIVER *** [%s %s] [%s]" %("XXXXX Flop cards XXXXXX", "XXXXX Turn Card XXXXX", "XXXXX River Card XXXXX")
-			for act in hand.actions['RIVER']:
-				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)
 
-		print "*** SUMMARY ***"
-		print "XXXXXXXXXXXX Need sumary info XXXXXXXXXXX"
-#		print "Total pot $%s | Rake $%s)" %(hand.totalpot  $" + hand.rake)
-#		print "Board [" + boardcards + "]"
-#
-#		SUMMARY STUFF
+        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])
+    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'}
     def __init__(self, sitename, gametype, string):
-	self.sitename = sitename
-	self.gametype = gametype
-	self.string = 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
+        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 = {} # 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.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"""
+        #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.streetList:
+            self.bets[street][name] = []
 
-	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 = 0
-	self.rake = 0
+    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'
+        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 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
+        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 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.streetList:
+                    #print street, self.bets[street][player]
+                    self.totalpot += reduce(operator.add, self.bets[street][player], 0)
+                    
+
 
     def printHand(self):
-	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
+        # 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)
+
+        #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[self.hero][0], self.holecards[self.hero][1])
+
+        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 '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"))
+        
+        #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):
+        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])
+
+    # 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
diff --git a/pyfpdb/Hud.py b/pyfpdb/Hud.py
index 8dbb53a6..e2147517 100644
--- a/pyfpdb/Hud.py
+++ b/pyfpdb/Hud.py
@@ -121,6 +121,19 @@ class Hud:
             self.main_window.gdkhandle.set_transient_for(self.main_window.parentgdkhandle) #
         
         self.main_window.set_destroy_with_parent(True)
+        
+    def update_table_position(self):
+        (x, y) = self.main_window.parentgdkhandle.get_origin()
+        if self.table.x != x or self.table.y != y:
+            self.table.x = x
+            self.table.y = y
+            self.main_window.move(x, y)
+            adj = self.adj_seats(self.hand, self.config)
+            loc = self.config.get_locations(self.table.site, self.max)
+            for i in range(1, self.max + 1):           
+                (x, y) = loc[adj[i]]
+                if self.stat_windows.has_key(i):
+                    self.stat_windows[i].relocate(x, y)
 
     def on_button_press(self, widget, event):
         if event.button == 1:
@@ -138,9 +151,7 @@ class Hud:
         self.deleted = True
 
     def reposition_windows(self, *args):
-        for w in self.stat_windows:
-                self.stat_windows[w].window.move(self.stat_windows[w].x,
-                                                 self.stat_windows[w].y)
+        self.update_table_position()
 
     def debug_stat_windows(self, *args):
         print self.table, "\n", self.main_window.window.get_transient_for()
@@ -213,10 +224,17 @@ class Hud:
         game_params = config.get_game_parameters(self.poker_game)
         if not game_params['aux'] == "":
             aux_params = config.get_aux_parameters(game_params['aux'])
+<<<<<<< HEAD:pyfpdb/Hud.py
             self.aux_windows.append(eval("%s.%s(gtk.Window(), self, config, 'fpdb')" % (aux_params['module'], aux_params['class'])))
+=======
+            self.aux_windows.append(eval("%s.%s(gtk.Window(), config, 'fpdb')" % (aux_params['module'], aux_params['class'])))
+        
+        gobject.timeout_add(0.5, self.update_table_position)
+>>>>>>> f607b3ff632a015de2cdbe2a92f706d90b116458:pyfpdb/Hud.py
             
     def update(self, hand, config, stat_dict):
         self.hand = hand   # this is the last hand, so it is available later
+        self.update_table_position()
         for s in stat_dict.keys():
             try:
                 self.stat_windows[stat_dict[s]['seat']].player_id = stat_dict[s]['player_id']
@@ -261,9 +279,9 @@ class Hud:
         for w in tl_windows:
             if w[1] == unique_name:
                 #win32gui.ShowWindow(w[0], win32con.SW_HIDE)
-                window.parentgdkhandle = gtk.gdk.window_foreign_new(long(self.table.number))
+                self.main_window.parentgdkhandle = gtk.gdk.window_foreign_new(long(self.table.number))
                 self.main_window.gdkhandle = gtk.gdk.window_foreign_new(w[0])
-                self.main_window.gdkhandle.set_transient_for(window.parentgdkhandle)
+                self.main_window.gdkhandle.set_transient_for(self.main_window.parentgdkhandle)
                 #win32gui.ShowWindow(w[0], win32con.SW_SHOW)
                 
                 style = win32gui.GetWindowLong(self.table.number, win32con.GWL_EXSTYLE)
@@ -308,6 +326,7 @@ class Stat_Window:
             pass
 
         if event.button == 1:   # left button event
+            # TODO: make position saving save sizes as well?
             if event.state & gtk.gdk.SHIFT_MASK:
                 self.window.begin_resize_drag(gtk.gdk.WINDOW_EDGE_SOUTH_EAST, event.button, int(event.x_root), int(event.y_root), event.time)
             else:
diff --git a/pyfpdb/RegressionTest.py b/pyfpdb/RegressionTest.py
index 26588ba0..2b09d248 100644
--- a/pyfpdb/RegressionTest.py
+++ b/pyfpdb/RegressionTest.py
@@ -35,72 +35,72 @@ import unittest
 
 class TestSequenceFunctions(unittest.TestCase):
 
-	def setUp(self):
-		"""Configure MySQL settings/database and establish connection"""
-		self.c = Configuration.Config()
-		self.mysql_settings={ 'db-host':"localhost", 
-					'db-backend':2, 
-					'db-databaseName':"fpdbtest", 
-					'db-user':"fpdb", 
-					'db-password':"fpdb"}
-		self.mysql_db = fpdb_db.fpdb_db()
-		self.mysql_db.connect(self.mysql_settings['db-backend'], self.mysql_settings['db-host'],
-					self.mysql_settings['db-databaseName'], self.mysql_settings['db-user'],
-					self.mysql_settings['db-password'])
-		self.mysqldict = FpdbSQLQueries.FpdbSQLQueries('MySQL InnoDB')
-		self.mysqlimporter = fpdb_import.Importer(self, self.mysql_settings, self.c)
-		self.mysqlimporter.setCallHud(False)
+    def setUp(self):
+        """Configure MySQL settings/database and establish connection"""
+        self.c = Configuration.Config()
+        self.mysql_settings={ 'db-host':"localhost", 
+                    'db-backend':2, 
+                    'db-databaseName':"fpdbtest", 
+                    'db-user':"fpdb", 
+                    'db-password':"fpdb"}
+        self.mysql_db = fpdb_db.fpdb_db()
+        self.mysql_db.connect(self.mysql_settings['db-backend'], self.mysql_settings['db-host'],
+                    self.mysql_settings['db-databaseName'], self.mysql_settings['db-user'],
+                    self.mysql_settings['db-password'])
+        self.mysqldict = FpdbSQLQueries.FpdbSQLQueries('MySQL InnoDB')
+        self.mysqlimporter = fpdb_import.Importer(self, self.mysql_settings, self.c)
+        self.mysqlimporter.setCallHud(False)
 
-#		"""Configure Postgres settings/database and establish connection"""
-#		self.pg_settings={ 'db-host':"localhost", 'db-backend':3, 'db-databaseName':"fpdbtest", 'db-user':"fpdb", 'db-password':"fpdb"}
-#		self.pg_db = fpdb_db.fpdb_db()
-#		self.pg_db.connect(self.pg_settings['db-backend'], self.pg_settings['db-host'],
-#					self.pg_settings['db-databaseName'], self.pg_settings['db-user'],
-#					self.pg_settings['db-password'])
-#		self.pgdict = FpdbSQLQueries.FpdbSQLQueries('PostgreSQL')
+#        """Configure Postgres settings/database and establish connection"""
+#        self.pg_settings={ 'db-host':"localhost", 'db-backend':3, 'db-databaseName':"fpdbtest", 'db-user':"fpdb", 'db-password':"fpdb"}
+#        self.pg_db = fpdb_db.fpdb_db()
+#        self.pg_db.connect(self.pg_settings['db-backend'], self.pg_settings['db-host'],
+#                    self.pg_settings['db-databaseName'], self.pg_settings['db-user'],
+#                    self.pg_settings['db-password'])
+#        self.pgdict = FpdbSQLQueries.FpdbSQLQueries('PostgreSQL')
 
 
-	def testDatabaseConnection(self):
-		"""Test all supported DBs"""
-		self.result = self.mysql_db.cursor.execute(self.mysqldict.query['list_tables'])
-		self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
+    def testDatabaseConnection(self):
+        """Test all supported DBs"""
+        self.result = self.mysql_db.cursor.execute(self.mysqldict.query['list_tables'])
+        self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
 
-#		self.result = self.pg_db.cursor.execute(self.pgdict.query['list_tables'])
-#		self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
+#        self.result = self.pg_db.cursor.execute(self.pgdict.query['list_tables'])
+#        self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
 
-	def testMySQLRecreateTables(self):
-		"""Test droping then recreating fpdb table schema"""
-		self.mysql_db.recreate_tables()
-		self.result = self.mysql_db.cursor.execute("SHOW TABLES")
-		self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
+    def testMySQLRecreateTables(self):
+        """Test droping then recreating fpdb table schema"""
+        self.mysql_db.recreate_tables()
+        self.result = self.mysql_db.cursor.execute("SHOW TABLES")
+        self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
 
-	def testPokerStarsHHDate(self):
-		latest = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/11/12 10:00:48 CET [2008/11/12 4:00:48 ET]"
-		previous = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/08/17 - 01:14:43 (ET)"
-		older1 = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/09/07 06:23:14 ET"
+    def testPokerStarsHHDate(self):
+        latest = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/11/12 10:00:48 CET [2008/11/12 4:00:48 ET]"
+        previous = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/08/17 - 01:14:43 (ET)"
+        older1 = "PokerStars Game #21969660557:  Hold'em No Limit ($0.50/$1.00) - 2008/09/07 06:23:14 ET"
 
-		result = fpdb_simple.parseHandStartTime(older1, "ps")
-		self.failUnless(result==datetime.datetime(2008,9,7,11,23,14),
-						"Date incorrect, expected: 2008-09-07 11:23:14 got: " + str(result))
-		result = fpdb_simple.parseHandStartTime(latest, "ps")
-		self.failUnless(result==datetime.datetime(2008,11,12,15,00,48), 
-						"Date incorrect, expected: 2008-11-12 15:00:48 got: " + str(result))
-		result = fpdb_simple.parseHandStartTime(previous, "ps")
-		self.failUnless(result==datetime.datetime(2008,8,17,6,14,43),
-						"Date incorrect, expected: 2008-08-17 01:14:43 got: " + str(result))
+        result = fpdb_simple.parseHandStartTime(older1, "ps")
+        self.failUnless(result==datetime.datetime(2008,9,7,11,23,14),
+                        "Date incorrect, expected: 2008-09-07 11:23:14 got: " + str(result))
+        result = fpdb_simple.parseHandStartTime(latest, "ps")
+        self.failUnless(result==datetime.datetime(2008,11,12,15,00,48), 
+                        "Date incorrect, expected: 2008-11-12 15:00:48 got: " + str(result))
+        result = fpdb_simple.parseHandStartTime(previous, "ps")
+        self.failUnless(result==datetime.datetime(2008,8,17,6,14,43),
+                        "Date incorrect, expected: 2008-08-17 01:14:43 got: " + str(result))
 
-	def testImportHandHistoryFiles(self):
-		"""Test import of single HH file"""
-		self.mysqlimporter.addImportFile("regression-test-files/hand-histories/ps-lhe-ring-3hands.txt")
-		self.mysqlimporter.runImport()
-		self.mysqlimporter.addImportDirectory("regression-test-files/hand-histories")
-		self.mysqlimporter.runImport()
+    def testImportHandHistoryFiles(self):
+        """Test import of single HH file"""
+        self.mysqlimporter.addImportFile("regression-test-files/hand-histories/ps-lhe-ring-3hands.txt")
+        self.mysqlimporter.runImport()
+        self.mysqlimporter.addImportDirectory("regression-test-files/hand-histories")
+        self.mysqlimporter.runImport()
 
-#	def testPostgresSQLRecreateTables(self):
-#		"""Test droping then recreating fpdb table schema"""
-#		self.pg_db.recreate_tables()
-#		self.result = self.pg_db.cursor.execute(self.pgdict.query['list_tables'])
-#		self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
+#    def testPostgresSQLRecreateTables(self):
+#        """Test droping then recreating fpdb table schema"""
+#        self.pg_db.recreate_tables()
+#        self.result = self.pg_db.cursor.execute(self.pgdict.query['list_tables'])
+#        self.failUnless(self.result==13, "Number of tables in database incorrect. Expected 13 got " + str(self.result))
 
 if __name__ == '__main__':
         unittest.main()
diff --git a/pyfpdb/SQL.py b/pyfpdb/SQL.py
index 724ba8ed..8a58cc58 100644
--- a/pyfpdb/SQL.py
+++ b/pyfpdb/SQL.py
@@ -229,12 +229,11 @@ class Sql:
                         sum(street3CheckCallRaiseDone)   AS ccr_3,
                         sum(street4CheckCallRaiseChance) AS ccr_opp_4,
                         sum(street4CheckCallRaiseDone)   AS ccr_4
-                    FROM HudCache, Hands
-                    WHERE HudCache.PlayerId in 
-                        (SELECT PlayerId FROM HandsPlayers 
-                        WHERE handId = %s)
-                    AND   Hands.id = %s
-                    AND   Hands.gametypeId = HudCache.gametypeId
+                    FROM Hands
+                         INNER JOIN HandsPlayers ON (HandsPlayers.handId = %s)
+                         INNER JOIN HudCache ON (    HudCache.PlayerId = HandsPlayers.PlayerId+0
+                                                 AND HudCache.gametypeId+0 = Hands.gametypeId+0)
+                    WHERE Hands.id = %s
                     GROUP BY HudCache.PlayerId
                 """
 
diff --git a/pyfpdb/Stats.py b/pyfpdb/Stats.py
index db2ada2e..80b3c7f1 100644
--- a/pyfpdb/Stats.py
+++ b/pyfpdb/Stats.py
@@ -71,6 +71,7 @@ def do_stat(stat_dict, player = 24, stat = 'vpip'):
 #    functions that return individual stats
 
 def playername(stat_dict, player):
+    """    Player Name."""
     return (stat_dict[player]['screen_name'],
             stat_dict[player]['screen_name'],
             stat_dict[player]['screen_name'],
@@ -98,6 +99,26 @@ def vpip(stat_dict, player):
                     'Voluntarily Put In Pot %'
                     )
 
+def vpip_0(stat_dict, player):
+    """    Voluntarily put $ in the pot (no decimals)."""
+    stat = 0.0
+    try:
+        stat = float(stat_dict[player]['vpip'])/float(stat_dict[player]['n'])
+        return (stat, 
+                '%2.0f'      % (100*stat) + '%', 
+                'v=%2.0f'    % (100*stat) + '%', 
+                'vpip=%2.0f' % (100*stat) + '%', 
+                '(%d/%d)'    % (stat_dict[player]['vpip'], stat_dict[player]['n']),
+                'vpip'
+                )
+    except: return (stat, 
+                    '%2.0f'      % (0) + '%', 
+                    'w=%2.0f'    % (0) + '%', 
+                    'wtsd=%2.0f' % (0) + '%', 
+                    '(%d/%d)'    % (0, 0),
+                    'wtsd'
+                    )
+
 def pfr(stat_dict, player):
     """    Preflop (3rd street) raise."""
     stat = 0.0
@@ -119,6 +140,27 @@ def pfr(stat_dict, player):
                 'Pre-Flop Raise %'
                 )
 
+def pfr_0(stat_dict, player):
+    """    Preflop (3rd street) raise (no decimals)."""
+    stat = 0.0
+    try:
+        stat = float(stat_dict[player]['pfr'])/float(stat_dict[player]['n'])
+        return (stat, 
+                '%2.0f'      % (100*stat) + '%', 
+                'p=%2.0f'    % (100*stat) + '%', 
+                'pfr=%2.0f'  % (100*stat) + '%', 
+                '(%d/%d)'    % (stat_dict[player]['pfr'], stat_dict[player]['n']),
+                'pfr'
+                )
+    except: 
+        return (stat, 
+                '%2.0f'      % (0) + '%', 
+                'p=%2.0f'    % (0) + '%', 
+                'pfr=%2.0f' % (0) + '%', 
+                '(%d/%d)'    % (0, 0),
+                'pfr'
+                )
+
 def wtsd(stat_dict, player):
     """    Went to SD when saw flop/4th."""
     stat = 0.0
@@ -149,7 +191,7 @@ def wmsd(stat_dict, player):
                 '%3.1f'      % (100*stat) + '%', 
                 'w=%3.1f'    % (100*stat) + '%', 
                 'wmsd=%3.1f' % (100*stat) + '%', 
-                '(%f5.0/%d)'    % (stat_dict[player]['wmsd'], stat_dict[player]['sd']),
+                '(%5.1f/%d)'    % (float(stat_dict[player]['wmsd']), stat_dict[player]['sd']),
                 '% won money at showdown'
                 )
     except:
@@ -412,6 +454,61 @@ def a_freq_4(stat_dict, player):
                 '(%d/%d)'      % (0, 0),
                 'Aggression Freq 7th'
                 )
+
+def a_freq_123(stat_dict, player):
+    """    Post-Flop aggression frequency."""
+    stat = 0.0
+    try:
+        stat = float(  stat_dict[player]['aggr_1'] + stat_dict[player]['aggr_2'] + stat_dict[player]['aggr_3']
+                    ) / float(  stat_dict[player]['saw_1'] + stat_dict[player]['saw_2'] + stat_dict[player]['saw_3']);
+        return (stat,
+                '%3.1f'             % (100*stat) + '%', 
+                'afq=%3.1f'         % (100*stat) + '%', 
+                'postf_aggfq=%3.1f' % (100*stat) + '%', 
+                '(%d/%d)'           % (  stat_dict[player]['aggr_1']
+                                       + stat_dict[player]['aggr_2']
+                                       + stat_dict[player]['aggr_3']
+                                      ,  stat_dict[player]['saw_1']
+                                       + stat_dict[player]['saw_2']
+                                       + stat_dict[player]['saw_3']
+                                      ),
+                'Post-Flop Aggression Freq'
+                )
+    except:
+        return (stat,
+                '%2.0f'        % (0) + '%', 
+                'a3=%2.0f'     % (0) + '%', 
+                'a_fq_3=%2.0f' % (0) + '%', 
+                '(%d/%d)'      % (0, 0),
+                'Post-Flop Aggression Freq'
+                )
+
+def a_freq_123_0(stat_dict, player):
+    """    Post-Flop aggression frequency (no decimals)."""
+    stat = 0.0
+    try:
+        stat = float(  stat_dict[player]['aggr_1'] + stat_dict[player]['aggr_2'] + stat_dict[player]['aggr_3']) / float(  stat_dict[player]['saw_1'] + stat_dict[player]['saw_2'] + stat_dict[player]['saw_3']);
+        return (stat,
+                '%2.0f'             % (100*stat) + '%', 
+                'afq=%2.0f'         % (100*stat) + '%', 
+                'postf_aggfq=%2.0f' % (100*stat) + '%', 
+                '(%d/%d)'           % (  stat_dict[player]['aggr_1']
+                                       + stat_dict[player]['aggr_2']
+                                       + stat_dict[player]['aggr_3']
+                                      ,  stat_dict[player]['saw_1']
+                                       + stat_dict[player]['saw_2']
+                                       + stat_dict[player]['saw_3']
+                                      ),
+                'Post-Flop Aggression Freq'
+                )
+    except:
+        return (stat,
+                '%2.0f'        % (0) + '%', 
+                'a3=%2.0f'     % (0) + '%', 
+                'a_fq_3=%2.0f' % (0) + '%', 
+                '(%d/%d)'      % (0, 0),
+                'Post-Flop Aggression Freq'
+                )
     
 def cb_1(stat_dict, player):
     """    Flop continuation bet."""
@@ -589,7 +686,9 @@ if __name__== "__main__":
     
     for player in stat_dict.keys():
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'vpip') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'vpip_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'pfr') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'pfr_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'wtsd') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'saw_f') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'n') 
@@ -604,6 +703,8 @@ if __name__== "__main__":
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_2') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_3') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_4') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_123') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_123_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb_1') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb_2') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb_3') 
@@ -611,7 +712,8 @@ if __name__== "__main__":
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'ffreq_1') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'ffreq_2') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'ffreq_3') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'ffreq_4') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'ffreq_4')
+        print "\n" 
 
     print "\n\nLegal stats:"
     for attr in dir():
@@ -619,8 +721,8 @@ if __name__== "__main__":
         if attr in ("Configuration", "Database", "GInitiallyUnowned", "gtk", "pygtk",
                     "player", "c", "db_connection", "do_stat", "do_tip", "stat_dict",
                     "h"): continue
-        print attr, eval("%s.__doc__" % (attr))
+        print "%-14s %s" % (attr, eval("%s.__doc__" % (attr)))
 #        print "            <pu_stat pu_stat_name = \"%s\"> </pu_stat>" % (attr)
 
-    db_connection.close
+    db_connection.close_connection
 
diff --git a/pyfpdb/Tables.py b/pyfpdb/Tables.py
index 3e7bacc6..8d44c1ae 100755
--- a/pyfpdb/Tables.py
+++ b/pyfpdb/Tables.py
@@ -248,7 +248,9 @@ def get_nt_exe(hwnd):
     """Finds the name of the executable that the given window handle belongs to."""
     processid = win32process.GetWindowThreadProcessId(hwnd)
     pshandle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, processid[1])
-    return win32process.GetModuleFileNameEx(pshandle, 0)
+    exename = win32process.GetModuleFileNameEx(pshandle, 0)
+    win32api.CloseHandle(pshandle)
+    return exename
 
 def decode_windows(c, title, hwnd):
     """Gets window parameters from the window title and handle--Windows."""
diff --git a/pyfpdb/fpdb.py b/pyfpdb/fpdb.py
old mode 100755
new mode 100644
index bec9be78..7c442ef0
--- a/pyfpdb/fpdb.py
+++ b/pyfpdb/fpdb.py
@@ -37,6 +37,7 @@ import gtk
 import fpdb_db
 import fpdb_simple
 import GuiBulkImport
+import GuiPlayerStats
 import GuiTableViewer
 import GuiAutoImport
 import GuiGraphViewer
@@ -117,12 +118,12 @@ class fpdb:
 	
 	def dia_create_del_database(self, widget, data):
 		print "todo: implement dia_create_del_database"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_create_del_database
 	
 	def dia_create_del_user(self, widget, data):
 		print "todo: implement dia_create_del_user"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_create_del_user
 	
 	def dia_database_stats(self, widget, data):
@@ -132,17 +133,17 @@ class fpdb:
 	
 	def dia_delete_db_parts(self, widget, data):
 		print "todo: implement dia_delete_db_parts"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_delete_db_parts
 	
 	def dia_edit_profile(self, widget=None, data=None, create_default=False, path=None):
 		print "todo: implement dia_edit_profile"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_edit_profile
 
 	def dia_export_db(self, widget, data):
 		print "todo: implement dia_export_db"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_export_db
 	
 	def dia_get_db_root_credentials(self):
@@ -167,7 +168,7 @@ class fpdb:
 	
 	def dia_import_db(self, widget, data):
 		print "todo: implement dia_import_db"
-		obtain_global_lock()
+		self.obtain_global_lock()
 	#end def dia_import_db
 	
 	def dia_licensing(self, widget, data):
@@ -263,7 +264,11 @@ class fpdb:
 		
 		self.db = fpdb_db.fpdb_db()
 		#print "end of fpdb.load_profile, databaseName:",self.settings['db-databaseName']
-		self.db.connect(self.settings['db-backend'], self.settings['db-host'], self.settings['db-databaseName'], self.settings['db-user'], self.settings['db-password'])
+		self.db.connect(self.settings['db-backend'],
+            self.settings['db-host'],
+            self.settings['db-databaseName'],
+            self.settings['db-user'], 
+            self.settings['db-password'])
 		if self.db.wrongDbVersion:
 			diaDbVersionWarning = gtk.Dialog(title="Strong Warning - Invalid database version", parent=None, flags=0, buttons=(gtk.STOCK_OK,gtk.RESPONSE_OK))
 
@@ -283,7 +288,7 @@ class fpdb:
 			diaDbVersionWarning.destroy()
 
 		# Database connected to successfully, load queries to pass on to other classes
-                self.querydict = FpdbSQLQueries.FpdbSQLQueries(self.db.get_backend_name())
+		self.querydict = FpdbSQLQueries.FpdbSQLQueries(self.db.get_backend_name())
 	#end def load_profile
 	
 	def not_implemented(self):
@@ -326,6 +331,13 @@ class fpdb:
 		self.add_and_display_tab(bulk_tab, "Bulk Import")
 	#end def tab_bulk_import
 
+	def tab_player_stats(self, widget, data):
+		new_ps_thread=GuiPlayerStats.GuiPlayerStats(self.db, self.config, self.querydict)
+		self.threads.append(new_ps_thread)
+		ps_tab=new_ps_thread.get_vbox()
+		self.add_and_display_tab(ps_tab, "Player Stats")
+
+
 	def tab_main_help(self, widget, data):
 		"""Displays a tab with the main fpdb help screen"""
 		#print "start of tab_main_help"
@@ -384,7 +396,7 @@ This program is licensed under the AGPL3, see docs"""+os.sep+"agpl-3.0.txt")
 				("/Viewers/_Graphs", "<control>G", self.tabGraphViewer, 0, None ),
 				("/Viewers/Hand _Replayer (todo)", None, self.not_implemented, 0, None ),
 				("/Viewers/Player _Details (todo)", None, self.not_implemented, 0, None ),
-				("/Viewers/_Player Stats (tabulated view) (todo)", None, self.not_implemented, 0, None ),
+				("/Viewers/_Player Stats (tabulated view)", None, self.tab_player_stats, 0, None ),
 				("/Viewers/Starting _Hands (todo)", None, self.not_implemented, 0, None ),
 				("/Viewers/_Session Replayer (todo)", None, self.not_implemented, 0, None ),
 				("/Viewers/Poker_table Viewer (mostly obselete)", "<control>T", self.tab_table_viewer, 0, None ),
diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py
old mode 100755
new mode 100644
index 8165211c..e1c61c6d
--- a/pyfpdb/fpdb_db.py
+++ b/pyfpdb/fpdb_db.py
@@ -21,156 +21,171 @@ import fpdb_simple
 import FpdbSQLQueries
 
 class fpdb_db:
-	def __init__(self):
-		"""Simple constructor, doesnt really do anything"""
-		self.db=None
-		self.cursor=None
-		self.sql = {}
-		self.MYSQL_INNODB=2
-		self.PGSQL=3
-		self.SQLITE=4
-	#end def __init__
-	
-	def connect(self, backend, host, database, user, password):
-		"""Connects a database with the given parameters"""
-		self.backend=backend
-		self.host=host
-		self.database=database
-		self.user=user
-		self.password=password
-		if backend==self.MYSQL_INNODB:
-			import MySQLdb
-			self.db=MySQLdb.connect(host = host, user = user, passwd = password, db = database)
-		elif backend==self.PGSQL:
-			import psycopg2
-			self.db = psycopg2.connect(host = host, user = user, password = password, database = database)
-		else:
-			raise fpdb_simple.FpdbError("unrecognised database backend:"+backend)
-		self.cursor=self.db.cursor()
-		self.cursor.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED')
-		# Set up query dictionary as early in the connection process as we can.
-                self.sql = FpdbSQLQueries.FpdbSQLQueries(self.get_backend_name())
-		self.wrongDbVersion=False
-		try:
-			self.cursor.execute("SELECT * FROM Settings")
-			settings=self.cursor.fetchone()
-			if settings[0]!=118:
-				print "outdated or too new database version - please recreate tables"
-				self.wrongDbVersion=True
-		except:# _mysql_exceptions.ProgrammingError:
-			print "failed to read settings table - please recreate tables"
-			self.wrongDbVersion=True
-	#end def connect
+    def __init__(self):
+        """Simple constructor, doesnt really do anything"""
+        self.db=None
+        self.cursor=None
+        self.sql = {}
+        self.MYSQL_INNODB=2
+        self.PGSQL=3
+        self.SQLITE=4
+    #end def __init__
+    
+    def connect(self, backend=None, host=None, database=None,
+                user=None, password=None):
+        """Connects a database with the given parameters"""
+        if backend is None:
+            raise FpdbError('Database backend not defined')
+        self.backend=backend
+        self.host=host
+        self.user=user
+        self.password=password
+        self.database=database
+        if backend==self.MYSQL_INNODB:
+            import MySQLdb
+            self.db=MySQLdb.connect(host = host, user = user, passwd = password, db = database)
+        elif backend==self.PGSQL:
+            import psycopg2
+            # If DB connection is made over TCP, then the variables
+            # host, user and password are required
+            print "host=%s user=%s pass=%s." % (host, user, password)
+            if self.host and self.user and self.password:
+                self.db = psycopg2.connect(host = host,
+                        user = user, 
+                        password = password, 
+                        database = database)
+            # For local domain-socket connections, only DB name is
+            # needed, and everything else is in fact undefined and/or
+            # flat out wrong
+            else:
+                self.db = psycopg2.connect(database = database)
+        else:
+            raise fpdb_simple.FpdbError("unrecognised database backend:"+backend)
+        self.cursor=self.db.cursor()
+        self.cursor.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED')
+        # Set up query dictionary as early in the connection process as we can.
+        self.sql = FpdbSQLQueries.FpdbSQLQueries(self.get_backend_name())
+        self.wrongDbVersion=False
+        try:
+            self.cursor.execute("SELECT * FROM Settings")
+            settings=self.cursor.fetchone()
+            if settings[0]!=118:
+                print "outdated or too new database version - please recreate tables"
+                self.wrongDbVersion=True
+        except:# _mysql_exceptions.ProgrammingError:
+            print "failed to read settings table - please recreate tables"
+            self.wrongDbVersion=True
+    #end def connect
 
-	def disconnect(self, due_to_error=False):
-		"""Disconnects the DB"""
-		if due_to_error:
-			self.db.rollback()
-		else:
-			self.db.commit()
-		self.cursor.close()
-		self.db.close()
-	#end def disconnect
-	
-	def reconnect(self, due_to_error=False):
-		"""Reconnects the DB"""
-		#print "started fpdb_db.reconnect"
-		self.disconnect(due_to_error)
-		self.connect(self.backend, self.host, self.database, self.user, self.password)
+    def disconnect(self, due_to_error=False):
+        """Disconnects the DB"""
+        if due_to_error:
+            self.db.rollback()
+        else:
+            self.db.commit()
+        self.cursor.close()
+        self.db.close()
+    #end def disconnect
+    
+    def reconnect(self, due_to_error=False):
+        """Reconnects the DB"""
+        #print "started fpdb_db.reconnect"
+        self.disconnect(due_to_error)
+        self.connect(self.backend, self.host, self.database, self.user, self.password)
 
-	def create_tables(self):
-		#todo: should detect and fail gracefully if tables already exist.
-		self.cursor.execute(self.sql.query['createSettingsTable'])
-		self.cursor.execute(self.sql.query['createSitesTable'])
-		self.cursor.execute(self.sql.query['createGametypesTable'])
-		self.cursor.execute(self.sql.query['createPlayersTable'])
-		self.cursor.execute(self.sql.query['createAutoratesTable'])
-		self.cursor.execute(self.sql.query['createHandsTable'])
-		self.cursor.execute(self.sql.query['createBoardCardsTable'])
-		self.cursor.execute(self.sql.query['createTourneyTypesTable'])
-		self.cursor.execute(self.sql.query['createTourneysTable'])
-		self.cursor.execute(self.sql.query['createTourneysPlayersTable'])
-		self.cursor.execute(self.sql.query['createHandsPlayersTable'])
-		self.cursor.execute(self.sql.query['createHandsActionsTable'])
-		self.cursor.execute(self.sql.query['createHudCacheTable'])
-		self.cursor.execute(self.sql.query['addTourneyIndex'])
-		self.cursor.execute(self.sql.query['addHandsIndex'])
-		self.cursor.execute(self.sql.query['addPlayersIndex'])
-		self.fillDefaultData()
-		self.db.commit()
+    def create_tables(self):
+        #todo: should detect and fail gracefully if tables already exist.
+        self.cursor.execute(self.sql.query['createSettingsTable'])
+        self.cursor.execute(self.sql.query['createSitesTable'])
+        self.cursor.execute(self.sql.query['createGametypesTable'])
+        self.cursor.execute(self.sql.query['createPlayersTable'])
+        self.cursor.execute(self.sql.query['createAutoratesTable'])
+        self.cursor.execute(self.sql.query['createHandsTable'])
+        self.cursor.execute(self.sql.query['createBoardCardsTable'])
+        self.cursor.execute(self.sql.query['createTourneyTypesTable'])
+        self.cursor.execute(self.sql.query['createTourneysTable'])
+        self.cursor.execute(self.sql.query['createTourneysPlayersTable'])
+        self.cursor.execute(self.sql.query['createHandsPlayersTable'])
+        self.cursor.execute(self.sql.query['createHandsActionsTable'])
+        self.cursor.execute(self.sql.query['createHudCacheTable'])
+        self.cursor.execute(self.sql.query['addTourneyIndex'])
+        self.cursor.execute(self.sql.query['addHandsIndex'])
+        self.cursor.execute(self.sql.query['addPlayersIndex'])
+        self.fillDefaultData()
+        self.db.commit()
 #end def disconnect
-	
-	def drop_tables(self):
-		"""Drops the fpdb tables from the current db"""
+    
+    def drop_tables(self):
+        """Drops the fpdb tables from the current db"""
 
-		if(self.get_backend_name() == 'MySQL InnoDB'):
-			#Databases with FOREIGN KEY support need this switched of before you can drop tables
-                	self.drop_referencial_integrity()
+        if(self.get_backend_name() == 'MySQL InnoDB'):
+            #Databases with FOREIGN KEY support need this switched of before you can drop tables
+            self.drop_referencial_integrity()
 
-			# Query the DB to see what tables exist
-			self.cursor.execute(self.sql.query['list_tables'])
-	                for table in self.cursor:
-                	        self.cursor.execute(self.sql.query['drop_table'] + table[0])
-		elif(self.get_backend_name() == 'PostgreSQL'):
-			self.db.commit()# I have no idea why this makes the query work--REB 07OCT2008
-			self.cursor.execute(self.sql.query['list_tables'])
-			tables = self.cursor.fetchall()
-	                for table in tables:
-                	        self.cursor.execute(self.sql.query['drop_table'] + table[0] + ' cascade') 
-		elif(self.get_backend_name() == 'SQLite'):
-			#todo: sqlite version here
-			print "Empty function here"
+            # Query the DB to see what tables exist
+            self.cursor.execute(self.sql.query['list_tables'])
+            for table in self.cursor:
+                self.cursor.execute(self.sql.query['drop_table'] + table[0])
+        elif(self.get_backend_name() == 'PostgreSQL'):
+            self.db.commit()# I have no idea why this makes the query work--REB 07OCT2008
+            self.cursor.execute(self.sql.query['list_tables'])
+            tables = self.cursor.fetchall()
+            for table in tables:
+                self.cursor.execute(self.sql.query['drop_table'] + table[0] + ' cascade') 
+        elif(self.get_backend_name() == 'SQLite'):
+            #todo: sqlite version here
+            print "Empty function here"
 
-                self.db.commit()
-	#end def drop_tables
+            self.db.commit()
+    #end def drop_tables
 
-	def drop_referencial_integrity(self):
-		"""Update all tables to remove foreign keys"""
+    def drop_referencial_integrity(self):
+        """Update all tables to remove foreign keys"""
 
-		self.cursor.execute(self.sql.query['list_tables'])
-		result = self.cursor.fetchall()
+        self.cursor.execute(self.sql.query['list_tables'])
+        result = self.cursor.fetchall()
 
-		for i in range(len(result)):
-			self.cursor.execute("SHOW CREATE TABLE " + result[i][0])
-			inner = self.cursor.fetchall()
+        for i in range(len(result)):
+            self.cursor.execute("SHOW CREATE TABLE " + result[i][0])
+            inner = self.cursor.fetchall()
 
-			for j in range(len(inner)):
-			# result[i][0] - Table name
-			# result[i][1] - CREATE TABLE parameters
-			#Searching for CONSTRAINT `tablename_ibfk_1`
-				for m in re.finditer('(ibfk_[0-9]+)', inner[j][1]):
-					key = "`" + inner[j][0] + "_" + m.group() + "`"
-					self.cursor.execute("ALTER TABLE " + inner[j][0] + " DROP FOREIGN KEY " + key)
+            for j in range(len(inner)):
+            # result[i][0] - Table name
+            # result[i][1] - CREATE TABLE parameters
+            #Searching for CONSTRAINT `tablename_ibfk_1`
+                for m in re.finditer('(ibfk_[0-9]+)', inner[j][1]):
+                    key = "`" + inner[j][0] + "_" + m.group() + "`"
+                    self.cursor.execute("ALTER TABLE " + inner[j][0] + " DROP FOREIGN KEY " + key)
                 self.db.commit()
         #end drop_referencial_inegrity
-	
-	def get_backend_name(self):
-		"""Returns the name of the currently used backend"""
-		if self.backend==2:
-			return "MySQL InnoDB"
-		elif self.backend==3:
-			return "PostgreSQL"
-		else:
-			raise fpdb_simple.FpdbError("invalid backend")
-	#end def get_backend_name
-	
-	def get_db_info(self):
-		return (self.host, self.database, self.user, self.password)
-	#end def get_db_info
-	
-	def fillDefaultData(self):
-		self.cursor.execute("INSERT INTO Settings VALUES (118);")
-		self.cursor.execute("INSERT INTO Sites VALUES (DEFAULT, 'Full Tilt Poker', 'USD');")
-		self.cursor.execute("INSERT INTO Sites VALUES (DEFAULT, 'PokerStars', 'USD');")
-		self.cursor.execute("INSERT INTO TourneyTypes VALUES (DEFAULT, 1, 0, 0, 0, False);")
-	#end def fillDefaultData
-	
-	def recreate_tables(self):
-		"""(Re-)creates the tables of the current DB"""
-		
-		self.drop_tables()
-		self.create_tables()
-		self.db.commit()
-		print "Finished recreating tables"
-	#end def recreate_tables
+    
+    def get_backend_name(self):
+        """Returns the name of the currently used backend"""
+        if self.backend==2:
+            return "MySQL InnoDB"
+        elif self.backend==3:
+            return "PostgreSQL"
+        else:
+            raise fpdb_simple.FpdbError("invalid backend")
+    #end def get_backend_name
+    
+    def get_db_info(self):
+        return (self.host, self.database, self.user, self.password)
+    #end def get_db_info
+    
+    def fillDefaultData(self):
+        self.cursor.execute("INSERT INTO Settings VALUES (118);")
+        self.cursor.execute("INSERT INTO Sites VALUES (DEFAULT, 'Full Tilt Poker', 'USD');")
+        self.cursor.execute("INSERT INTO Sites VALUES (DEFAULT, 'PokerStars', 'USD');")
+        self.cursor.execute("INSERT INTO TourneyTypes VALUES (DEFAULT, 1, 0, 0, 0, False);")
+    #end def fillDefaultData
+    
+    def recreate_tables(self):
+        """(Re-)creates the tables of the current DB"""
+        
+        self.drop_tables()
+        self.create_tables()
+        self.db.commit()
+        print "Finished recreating tables"
+    #end def recreate_tables
 #end class fpdb_db
diff --git a/pyfpdb/fpdb_import.py b/pyfpdb/fpdb_import.py
old mode 100755
new mode 100644
index 0ff8179c..2e88899c
--- a/pyfpdb/fpdb_import.py
+++ b/pyfpdb/fpdb_import.py
@@ -20,16 +20,16 @@
 import sys
 
 try:
-	import MySQLdb
-	mysqlLibFound=True
+    import MySQLdb
+    mysqlLibFound=True
 except:
-	pass
-	
+    pass
+    
 try:
-	import psycopg2
-	pgsqlLibFound=True
+    import psycopg2
+    pgsqlLibFound=True
 except:
-	pass
+    pass
 
 import traceback
 import math
@@ -42,274 +42,282 @@ from time import time
 
 class Importer:
 
-	def __init__(self, caller, settings, config):
-		"""Constructor"""
-		self.settings=settings
-		self.caller=caller
-		self.config = config
-		self.db = None
-		self.cursor = None
-		self.filelist = {}
-		self.dirlist = {}
-		self.monitor = False
-		self.updated = {}		#Time last import was run {file:mtime}
-		self.lines = None
-		self.faobs = None		#File as one big string
-		self.pos_in_file = {} # dict to remember how far we have read in the file
-		#Set defaults
-		self.callHud = self.config.get_import_parameters().get("callFpdbHud")
-		if not self.settings.has_key('minPrint'):
-			self.settings['minPrint'] = 30
-		self.dbConnect()
+    def __init__(self, caller, settings, config):
+        """Constructor"""
+        self.settings=settings
+        self.caller=caller
+        self.config = config
+        self.db = None
+        self.cursor = None
+        self.filelist = {}
+        self.dirlist = {}
+        self.monitor = False
+        self.updated = {}       #Time last import was run {file:mtime}
+        self.lines = None
+        self.faobs = None       #File as one big string
+        self.pos_in_file = {} # dict to remember how far we have read in the file
+        #Set defaults
+        self.callHud = self.config.get_import_parameters().get("callFpdbHud")
+        if not self.settings.has_key('minPrint'):
+            self.settings['minPrint'] = 30
+        self.dbConnect()
 
-	def dbConnect(self):
-		#connect to DB
-		if self.settings['db-backend'] == 2:
-			if not mysqlLibFound:
-				raise fpdb_simple.FpdbError("interface library MySQLdb not found but MySQL selected as backend - please install the library or change the config file")
-			self.db = MySQLdb.connect(self.settings['db-host'], self.settings['db-user'],
-							self.settings['db-password'], self.settings['db-databaseName'])
-		elif self.settings['db-backend'] == 3:
-			if not pgsqlLibFound:
-				raise fpdb_simple.FpdbError("interface library psycopg2 not found but PostgreSQL selected as backend - please install the library or change the config file")
-			print self.settings
-			self.db = psycopg2.connect(host = self.settings['db-host'],
-									   user = self.settings['db-user'],
-									   password = self.settings['db-password'],
-									   database = self.settings['db-databaseName'])
-		elif self.settings['db-backend'] == 4:
-			pass
-		else:
-			pass
-		self.cursor = self.db.cursor()
+    # XXX: Why is this here, when fpdb_db.connect() already does the
+    # same?
+    def dbConnect(self):
+        #connect to DB
+        if self.settings['db-backend'] == 2:
+            if not mysqlLibFound:
+                raise fpdb_simple.FpdbError("interface library MySQLdb not found but MySQL selected as backend - please install the library or change the config file")
+            self.db = MySQLdb.connect(self.settings['db-host'], self.settings['db-user'],
+                            self.settings['db-password'], self.settings['db-databaseName'])
+        elif self.settings['db-backend'] == 3:
+            if not pgsqlLibFound:
+                raise fpdb_simple.FpdbError("interface library psycopg2 not found but PostgreSQL selected as backend - please install the library or change the config file")
+            print self.settings
+            if self.settings.has_key('db-host') and \
+                        self.settings.has_key('db-user'):
+                self.db = psycopg2.connect(host = self.settings['db-host'],
+                                       user = self.settings['db-user'],
+                                       password = self.settings['db-password'],
+                                       database = self.settings['db-databaseName'])
+            else:
+                dbname = self.settings['db-databaseName']
+                self.db = psycopg2.connect(database = dbname)
+        elif self.settings['db-backend'] == 4:
+            pass
+        else:
+            pass
+        self.cursor = self.db.cursor()
 
-	#Set functions
-	def setCallHud(self, value):
-		self.callHud = value
+    #Set functions
+    def setCallHud(self, value):
+        self.callHud = value
 
-	def setMinPrint(self, value):
-		self.settings['minPrint'] = int(value)
+    def setMinPrint(self, value):
+        self.settings['minPrint'] = int(value)
 
-	def setHandCount(self, value):
-		self.settings['handCount'] = int(value)
+    def setHandCount(self, value):
+        self.settings['handCount'] = int(value)
 
-	def setQuiet(self, value):
-		self.settings['quiet'] = value
+    def setQuiet(self, value):
+        self.settings['quiet'] = value
 
-	def setFailOnError(self, value):
-		self.settings['failOnError'] = value
+    def setFailOnError(self, value):
+        self.settings['failOnError'] = value
 
-#	def setWatchTime(self):
-#		self.updated = time()
+#   def setWatchTime(self):
+#       self.updated = time()
 
-	def clearFileList(self):
-		self.filelist = {}
+    def clearFileList(self):
+        self.filelist = {}
 
-	#Add an individual file to filelist
-	def addImportFile(self, filename, site = "default", filter = "passthrough"):
-		#TODO: test it is a valid file
-		self.filelist[filename] = [site] + [filter]
+    #Add an individual file to filelist
+    def addImportFile(self, filename, site = "default", filter = "passthrough"):
+        #TODO: test it is a valid file
+        self.filelist[filename] = [site] + [filter]
 
-	#Add a directory of files to filelist
-	#Only one import directory per site supported.
-	#dirlist is a hash of lists:
-	#dirlist{ 'PokerStars' => ["/path/to/import/", "filtername"] }
-	def addImportDirectory(self,dir,monitor = False, site = "default", filter = "passthrough"):
-		if os.path.isdir(dir):
-			if monitor == True:
-				self.monitor = True
-				self.dirlist[site] = [dir] + [filter]
+    #Add a directory of files to filelist
+    #Only one import directory per site supported.
+    #dirlist is a hash of lists:
+    #dirlist{ 'PokerStars' => ["/path/to/import/", "filtername"] }
+    def addImportDirectory(self,dir,monitor = False, site = "default", filter = "passthrough"):
+        if os.path.isdir(dir):
+            if monitor == True:
+                self.monitor = True
+                self.dirlist[site] = [dir] + [filter]
 
-			for file in os.listdir(dir):
-				self.addImportFile(os.path.join(dir, file), site, filter)
-		else:
-			print "Warning: Attempted to add: '" + str(dir) + "' as an import directory"
+            for file in os.listdir(dir):
+                self.addImportFile(os.path.join(dir, file), site, filter)
+        else:
+            print "Warning: Attempted to add: '" + str(dir) + "' as an import directory"
 
-	#Run full import on filelist
-	def runImport(self):
-		for file in self.filelist:
-			self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
+    #Run full import on filelist
+    def runImport(self):
+        for file in self.filelist:
+            self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
 
-	#Run import on updated files, then store latest update time.
-	def runUpdated(self):
-		#Check for new files in directory
-		#todo: make efficient - always checks for new file, should be able to use mtime of directory
-		# ^^ May not work on windows
-		for site in self.dirlist:
-			self.addImportDirectory(self.dirlist[site][0], False, site, self.dirlist[site][1])
+    #Run import on updated files, then store latest update time.
+    def runUpdated(self):
+        #Check for new files in directory
+        #todo: make efficient - always checks for new file, should be able to use mtime of directory
+        # ^^ May not work on windows
+        for site in self.dirlist:
+            self.addImportDirectory(self.dirlist[site][0], False, site, self.dirlist[site][1])
 
-		for file in self.filelist:
-			stat_info = os.stat(file)
-			try: 
-				lastupdate = self.updated[file]
-				if stat_info.st_mtime > lastupdate:
-					self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
-					self.updated[file] = time()
-			except:
-				self.updated[file] = time()
-				# This codepath only runs first time the file is found, if modified in the last
-				# minute run an immediate import.
-				if (time() - stat_info.st_mtime) < 60:
-					self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
+        for file in self.filelist:
+            stat_info = os.stat(file)
+            try: 
+                lastupdate = self.updated[file]
+                if stat_info.st_mtime > lastupdate:
+                    self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
+                    self.updated[file] = time()
+            except:
+                self.updated[file] = time()
+                # This codepath only runs first time the file is found, if modified in the last
+                # minute run an immediate import.
+                if (time() - stat_info.st_mtime) < 60:
+                    self.import_file_dict(file, self.filelist[file][0], self.filelist[file][1])
 
-	# This is now an internal function that should not be called directly.
-	def import_file_dict(self, file, site, filter):
-		if(filter == "passthrough"):
-			self.import_fpdb_file(file, site)
-		else:
-			#Load filter, and run filtered file though main importer
-			self.import_fpdb_file(file, site)
+    # This is now an internal function that should not be called directly.
+    def import_file_dict(self, file, site, filter):
+        if(filter == "passthrough"):
+            self.import_fpdb_file(file, site)
+        else:
+            #Load filter, and run filtered file though main importer
+            self.import_fpdb_file(file, site)
 
 
-	def import_fpdb_file(self, file, site):
-		starttime = time()
-		last_read_hand=0
-		loc = 0
-		if (file=="stdin"):
-			inputFile=sys.stdin
-		else:
-			inputFile=open(file, "rU")
-			try: loc = self.pos_in_file[file]
-			except: pass
+    def import_fpdb_file(self, file, site):
+        starttime = time()
+        last_read_hand=0
+        loc = 0
+        if (file=="stdin"):
+            inputFile=sys.stdin
+        else:
+            inputFile=open(file, "rU")
+            try: loc = self.pos_in_file[file]
+            except: pass
 
-		# Read input file into class and close file
-		inputFile.seek(loc)
-		self.lines=fpdb_simple.removeTrailingEOL(inputFile.readlines())
-		self.pos_in_file[file] = inputFile.tell()
-		inputFile.close()
+        # Read input file into class and close file
+        inputFile.seek(loc)
+        self.lines=fpdb_simple.removeTrailingEOL(inputFile.readlines())
+        self.pos_in_file[file] = inputFile.tell()
+        inputFile.close()
 
-		try: # sometimes we seem to be getting an empty self.lines, in which case, we just want to return.
-			firstline = self.lines[0]
-		except:
-#			print "import_fpdb_file", file, site, self.lines, "\n"
-			return
+        try: # sometimes we seem to be getting an empty self.lines, in which case, we just want to return.
+            firstline = self.lines[0]
+        except:
+#           print "import_fpdb_file", file, site, self.lines, "\n"
+            return
 
-		if firstline.find("Tournament Summary")!=-1:
-			print "TODO: implement importing tournament summaries"
-			#self.faobs = readfile(inputFile)
-			#self.parseTourneyHistory()
-			return 0
-		
-		site=fpdb_simple.recogniseSite(firstline)
-		category=fpdb_simple.recogniseCategory(firstline)
+        if firstline.find("Tournament Summary")!=-1:
+            print "TODO: implement importing tournament summaries"
+            #self.faobs = readfile(inputFile)
+            #self.parseTourneyHistory()
+            return 0
+        
+        site=fpdb_simple.recogniseSite(firstline)
+        category=fpdb_simple.recogniseCategory(firstline)
 
-		startpos=0
-		stored=0 #counter
-		duplicates=0 #counter
-		partial=0 #counter
-		errors=0 #counter
+        startpos=0
+        stored=0 #counter
+        duplicates=0 #counter
+        partial=0 #counter
+        errors=0 #counter
 
-		for i in range (len(self.lines)): #main loop, iterates through the lines of a file and calls the appropriate parser method
-			if (len(self.lines[i])<2):
-				endpos=i
-				hand=self.lines[startpos:endpos]
-		
-				if (len(hand[0])<2):
-					hand=hand[1:]
-		
-				cancelled=False
-				damaged=False
-				if (site=="ftp"):
-					for i in range (len(hand)):
-						if (hand[i].endswith(" has been canceled")): #this is their typo. this is a typo, right?
-							cancelled=True
-						
-						seat1=hand[i].find("Seat ") #todo: make this recover by skipping this line
-						if (seat1!=-1):
-							if (hand[i].find("Seat ", seat1+3)!=-1):
-								damaged=True
-				
-				if (len(hand)<3):
-					pass
-					#todo: the above 2 lines are kind of a dirty hack, the mentioned circumstances should be handled elsewhere but that doesnt work with DOS/Win EOL. actually this doesnt work.
-				elif (hand[0].endswith(" (partial)")): #partial hand - do nothing
-					partial+=1
-				elif (hand[1].find("Seat")==-1 and hand[2].find("Seat")==-1 and hand[3].find("Seat")==-1):#todo: should this be or instead of and?
-					partial+=1
-				elif (cancelled or damaged):
-					partial+=1
-				else: #normal processing
-					isTourney=fpdb_simple.isTourney(hand[0])
-					if not isTourney:
-						fpdb_simple.filterAnteBlindFold(site,hand)
-					hand=fpdb_simple.filterCrap(site, hand, isTourney)
-					self.hand=hand
-					
-					try:
-						handsId=fpdb_parse_logic.mainParser(self.db, self.cursor, site, category, hand)
-						self.db.commit()
-						
-						stored+=1
-						self.db.commit()
-						if self.callHud:
-							#print "call to HUD here. handsId:",handsId
-							#pipe the Hands.id out to the HUD
-							self.caller.pipe_to_hud.stdin.write("%s" % (handsId) + os.linesep)
-					except fpdb_simple.DuplicateError:
-						duplicates+=1
-					except (ValueError), fe:
-						errors+=1
-						self.printEmailErrorMessage(errors, file, hand)
-				
-						if (self.settings['failOnError']):
-							self.db.commit() #dont remove this, in case hand processing was cancelled.
-							raise
-					except (fpdb_simple.FpdbError), fe:
-						errors+=1
-						self.printEmailErrorMessage(errors, file, hand)
+        for i in range (len(self.lines)): #main loop, iterates through the lines of a file and calls the appropriate parser method
+            if (len(self.lines[i])<2):
+                endpos=i
+                hand=self.lines[startpos:endpos]
+        
+                if (len(hand[0])<2):
+                    hand=hand[1:]
+        
+                cancelled=False
+                damaged=False
+                if (site=="ftp"):
+                    for i in range (len(hand)):
+                        if (hand[i].endswith(" has been canceled")): #this is their typo. this is a typo, right?
+                            cancelled=True
+                        
+                        seat1=hand[i].find("Seat ") #todo: make this recover by skipping this line
+                        if (seat1!=-1):
+                            if (hand[i].find("Seat ", seat1+3)!=-1):
+                                damaged=True
+                
+                if (len(hand)<3):
+                    pass
+                    #todo: the above 2 lines are kind of a dirty hack, the mentioned circumstances should be handled elsewhere but that doesnt work with DOS/Win EOL. actually this doesnt work.
+                elif (hand[0].endswith(" (partial)")): #partial hand - do nothing
+                    partial+=1
+                elif (hand[1].find("Seat")==-1 and hand[2].find("Seat")==-1 and hand[3].find("Seat")==-1):#todo: should this be or instead of and?
+                    partial+=1
+                elif (cancelled or damaged):
+                    partial+=1
+                else: #normal processing
+                    isTourney=fpdb_simple.isTourney(hand[0])
+                    if not isTourney:
+                        fpdb_simple.filterAnteBlindFold(site,hand)
+                    hand=fpdb_simple.filterCrap(site, hand, isTourney)
+                    self.hand=hand
+                    
+                    try:
+                        handsId=fpdb_parse_logic.mainParser(self.settings['db-backend'], self.db
+                                                           ,self.cursor, site, category, hand)
+                        self.db.commit()
+                        
+                        stored+=1
+                        self.db.commit()
+                        if self.callHud:
+                            #print "call to HUD here. handsId:",handsId
+                            #pipe the Hands.id out to the HUD
+                            self.caller.pipe_to_hud.stdin.write("%s" % (handsId) + os.linesep)
+                    except fpdb_simple.DuplicateError:
+                        duplicates+=1
+                    except (ValueError), fe:
+                        errors+=1
+                        self.printEmailErrorMessage(errors, file, hand)
+                
+                        if (self.settings['failOnError']):
+                            self.db.commit() #dont remove this, in case hand processing was cancelled.
+                            raise
+                    except (fpdb_simple.FpdbError), fe:
+                        errors+=1
+                        self.printEmailErrorMessage(errors, file, hand)
 
-						#fe.printStackTrace() #todo: get stacktrace
-						self.db.rollback()
-						
-						if (self.settings['failOnError']):
-							self.db.commit() #dont remove this, in case hand processing was cancelled.
-							raise
-					if (self.settings['minPrint']!=0):
-						if ((stored+duplicates+partial+errors)%self.settings['minPrint']==0):
-							print "stored:", stored, "duplicates:", duplicates, "partial:", partial, "errors:", errors
-			
-					if (self.settings['handCount']!=0):
-						if ((stored+duplicates+partial+errors)>=self.settings['handCount']):
-							if (not self.settings['quiet']):
-								print "quitting due to reaching the amount of hands to be imported"
-								print "Total stored:", stored, "duplicates:", duplicates, "partial/damaged:", partial, "errors:", errors, " time:", (time() - starttime)
-							sys.exit(0)
-				startpos=endpos
-		print "Total stored:", stored, "duplicates:", duplicates, "partial:", partial, "errors:", errors, " time:", (time() - starttime)
-		
-		if stored==0:
-			if duplicates>0:
-				for line_no in range(len(self.lines)):
-					if self.lines[line_no].find("Game #")!=-1:
-						final_game_line=self.lines[line_no]
-				handsId=fpdb_simple.parseSiteHandNo(final_game_line)
-			else:
-				print "failed to read a single hand from file:", inputFile
-				handsId=0
-			#todo: this will cause return of an unstored hand number if the last hand was error or partial
-		self.db.commit()
-		self.handsId=handsId
-		return handsId
+                        #fe.printStackTrace() #todo: get stacktrace
+                        self.db.rollback()
+                        
+                        if (self.settings['failOnError']):
+                            self.db.commit() #dont remove this, in case hand processing was cancelled.
+                            raise
+                    if (self.settings['minPrint']!=0):
+                        if ((stored+duplicates+partial+errors)%self.settings['minPrint']==0):
+                            print "stored:", stored, "duplicates:", duplicates, "partial:", partial, "errors:", errors
+            
+                    if (self.settings['handCount']!=0):
+                        if ((stored+duplicates+partial+errors)>=self.settings['handCount']):
+                            if (not self.settings['quiet']):
+                                print "quitting due to reaching the amount of hands to be imported"
+                                print "Total stored:", stored, "duplicates:", duplicates, "partial/damaged:", partial, "errors:", errors, " time:", (time() - starttime)
+                            sys.exit(0)
+                startpos=endpos
+        print "Total stored:", stored, "duplicates:", duplicates, "partial:", partial, "errors:", errors, " time:", (time() - starttime)
+        
+        if stored==0:
+            if duplicates>0:
+                for line_no in range(len(self.lines)):
+                    if self.lines[line_no].find("Game #")!=-1:
+                        final_game_line=self.lines[line_no]
+                handsId=fpdb_simple.parseSiteHandNo(final_game_line)
+            else:
+                print "failed to read a single hand from file:", inputFile
+                handsId=0
+            #todo: this will cause return of an unstored hand number if the last hand was error or partial
+        self.db.commit()
+        self.handsId=handsId
+        return handsId
 #end def import_file_dict
 
-	def parseTourneyHistory(self):
-		print "Tourney history parser stub"
-		#Find tournament boundaries.
-		#print self.foabs
-		
+    def parseTourneyHistory(self):
+        print "Tourney history parser stub"
+        #Find tournament boundaries.
+        #print self.foabs
+        
 
-	def printEmailErrorMessage(self, errors, filename, line):
-		traceback.print_exc(file=sys.stderr)
-		print "Error No.",errors,", please send the hand causing this to steffen@sycamoretest.info so I can fix it."
-		print "Filename:", filename
-		print "Here is the first line so you can identify it. Please mention that the error was a ValueError:"
-		print self.hand[0]
-		print "Hand logged to hand-errors.txt"
-		logfile = open('hand-errors.txt', 'a')
-		for s in self.hand:
-			logfile.write(str(s) + "\n")
-		logfile.write("\n")
-		logfile.close()
+    def printEmailErrorMessage(self, errors, filename, line):
+        traceback.print_exc(file=sys.stderr)
+        print "Error No.",errors,", please send the hand causing this to steffen@sycamoretest.info so I can fix it."
+        print "Filename:", filename
+        print "Here is the first line so you can identify it. Please mention that the error was a ValueError:"
+        print self.hand[0]
+        print "Hand logged to hand-errors.txt"
+        logfile = open('hand-errors.txt', 'a')
+        for s in self.hand:
+            logfile.write(str(s) + "\n")
+        logfile.write("\n")
+        logfile.close()
 
 if __name__ == "__main__":
-	print "CLI for fpdb_import is now available as CliFpdb.py"
+    print "CLI for fpdb_import is now available as CliFpdb.py"
diff --git a/pyfpdb/fpdb_parse_logic.py b/pyfpdb/fpdb_parse_logic.py
index 370a0fc0..a345dc93 100644
--- a/pyfpdb/fpdb_parse_logic.py
+++ b/pyfpdb/fpdb_parse_logic.py
@@ -21,146 +21,171 @@ import fpdb_simple
 import fpdb_save_to_db
 
 #parses a holdem hand
-def mainParser(db, cursor, site, category, hand):
-	if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
-		base="hold"
-	else:
-		base="stud"
-	#part 0: create the empty arrays
-	lineTypes=[] #char, valid values: header, name, cards, action, win, rake, ignore
-	lineStreets=[] #char, valid values: (predeal, preflop, flop, turn, river)
+def mainParser(backend, db, cursor, site, category, hand):
+    if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
+        base="hold"
+    else:
+        base="stud"
+    #part 0: create the empty arrays
+    lineTypes=[] #char, valid values: header, name, cards, action, win, rake, ignore
+    lineStreets=[] #char, valid values: (predeal, preflop, flop, turn, river)
 
-	cardValues, cardSuits, boardValues, boardSuits, antes, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo, seatLines, winnings, rakes=[],[],[],[],[],[],[],[],[],[],[],[],[]
+    cardValues, cardSuits, boardValues, boardSuits, antes, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo, seatLines, winnings, rakes=[],[],[],[],[],[],[],[],[],[],[],[],[]
 
-	#part 1: read hand no and check for duplicate
-	siteHandNo=fpdb_simple.parseSiteHandNo(hand[0])
-	handStartTime=fpdb_simple.parseHandStartTime(hand[0], site)
-	siteID=fpdb_simple.recogniseSiteID(cursor, site)
-	#print "parse logic, siteID:",siteID,"site:",site
-	
-	isTourney=fpdb_simple.isTourney(hand[0])
-	smallBlindLine=0
-	for i in range(len(hand)):
-		if hand[i].find("posts small blind")!=-1 or hand[i].find("posts the small blind")!=-1:
-			if hand[i][-2:] == "$0":
-				continue
-			smallBlindLine=i
-			#print "found small blind line:",smallBlindLine
-			break
-	#print "small blind line:",smallBlindLine
-	gametypeID=fpdb_simple.recogniseGametypeID(cursor, hand[0], hand[smallBlindLine], siteID, category, isTourney)
-	if isTourney:
-		if site!="ps":
-			raise fpdb_simple.FpdbError("tourneys are only supported on PS right now")
-		siteTourneyNo=fpdb_simple.parseTourneyNo(hand[0])
-		buyin=fpdb_simple.parseBuyin(hand[0])
-		fee=fpdb_simple.parseFee(hand[0])
-		entries=-1 #todo: parse this
-		prizepool=-1 #todo: parse this
-		knockout=0
-		tourneyStartTime=handStartTime #todo: read tourney start time
-		rebuyOrAddon=fpdb_simple.isRebuyOrAddon(hand[0])
+    #part 1: read hand no and check for duplicate
+    siteHandNo=fpdb_simple.parseSiteHandNo(hand[0])
+    handStartTime=fpdb_simple.parseHandStartTime(hand[0], site)
+    siteID=fpdb_simple.recogniseSiteID(cursor, site)
+    #print "parse logic, siteID:",siteID,"site:",site
+    
+    isTourney=fpdb_simple.isTourney(hand[0])
+    smallBlindLine=0
+    for i in range(len(hand)):
+        if hand[i].find("posts small blind")!=-1 or hand[i].find("posts the small blind")!=-1:
+            if hand[i][-2:] == "$0":
+                continue
+            smallBlindLine=i
+            #print "found small blind line:",smallBlindLine
+            break
+    #print "small blind line:",smallBlindLine
+    gametypeID=fpdb_simple.recogniseGametypeID(backend, db, cursor, hand[0], hand[smallBlindLine], siteID, category, isTourney)
+    if isTourney:
+        if site!="ps":
+            raise fpdb_simple.FpdbError("tourneys are only supported on PS right now")
+        siteTourneyNo=fpdb_simple.parseTourneyNo(hand[0])
+        buyin=fpdb_simple.parseBuyin(hand[0])
+        fee=fpdb_simple.parseFee(hand[0])
+        entries=-1 #todo: parse this
+        prizepool=-1 #todo: parse this
+        knockout=0
+        tourneyStartTime=handStartTime #todo: read tourney start time
+        rebuyOrAddon=fpdb_simple.isRebuyOrAddon(hand[0])
 
-		tourneyTypeId=fpdb_simple.recogniseTourneyTypeId(cursor, siteID, buyin, fee, knockout, rebuyOrAddon)		
-	fpdb_simple.isAlreadyInDB(cursor, gametypeID, siteHandNo)
-	
-	#part 2: classify lines by type (e.g. cards, action, win, sectionchange) and street
-	fpdb_simple.classifyLines(hand, category, lineTypes, lineStreets)
-		
-	#part 3: read basic player info	
-	#3a read player names, startcashes
-	for i in range (len(hand)): #todo: use maxseats+1 here.
-		if (lineTypes[i]=="name"):
-			seatLines.append(hand[i])
-	names=fpdb_simple.parseNames(seatLines)
-	playerIDs = fpdb_simple.recognisePlayerIDs(cursor, names, siteID)
-	tmp=fpdb_simple.parseCashesAndSeatNos(seatLines, site)
-	startCashes=tmp['startCashes']
-	seatNos=tmp['seatNos']
-	
-	fpdb_simple.createArrays(category, len(names), cardValues, cardSuits, antes, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo)
-	
-	#3b read positions
-	if base=="hold":
-		positions = fpdb_simple.parsePositions (hand, names)
-	
-	#part 4: take appropriate action for each line based on linetype
-	for i in range(len(hand)):
-		if (lineTypes[i]=="cards"):
-			fpdb_simple.parseCardLine (site, category, lineStreets[i], hand[i], names, cardValues, cardSuits, boardValues, boardSuits)
-			#if category=="studhilo":
-			#	print "hand[i]:", hand[i]
-			#	print "cardValues:", cardValues
-			#	print "cardSuits:", cardSuits
-		elif (lineTypes[i]=="action"):
-			fpdb_simple.parseActionLine (site, base, isTourney, hand[i], lineStreets[i], playerIDs, names, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo)
-		elif (lineTypes[i]=="win"):
-			fpdb_simple.parseWinLine (hand[i], site, names, winnings, isTourney)
-		elif (lineTypes[i]=="rake"):
-			if isTourney:
-				totalRake=0
-			else:
-				totalRake=fpdb_simple.parseRake(hand[i])
-			fpdb_simple.splitRake(winnings, rakes, totalRake)
-		elif (lineTypes[i]=="header" or lineTypes[i]=="rake" or lineTypes[i]=="name" or lineTypes[i]=="ignore"):
-			pass
-		elif (lineTypes[i]=="ante"):
-			fpdb_simple.parseAnteLine(hand[i], site, isTourney, names, antes)
-		elif (lineTypes[i]=="table"):
-			tableResult=fpdb_simple.parseTableLine(site, base, hand[i])
-		else:
-			raise fpdb_simple.FpdbError("unrecognised lineType:"+lineTypes[i])
-	if site=="ftp":
-		tableResult=fpdb_simple.parseTableLine(site, base, hand[0])
-	maxSeats=tableResult['maxSeats']
-	tableName=tableResult['tableName']
-	#print "before part5, antes:", antes
-	
-	#part 5: final preparations, then call fpdb_save_to_db.* with
-	#		 the arrays as they are - that file will fill them.
-	fpdb_simple.convertCardValues(cardValues)
-	if base=="hold":
-		fpdb_simple.convertCardValuesBoard(boardValues)
-		fpdb_simple.convertBlindBet(actionTypes, actionAmounts)
-		fpdb_simple.checkPositions(positions)
-		
-	cursor.execute("SELECT limitType FROM Gametypes WHERE id=%s",(gametypeID, ))
-	limit_type=cursor.fetchone()[0]
-	fpdb_simple.convert3B4B(site, category, limit_type, actionTypes, actionAmounts)
-	
-	totalWinnings=0
-	for i in range(len(winnings)):
-		totalWinnings+=winnings[i]
-	
-	if base=="hold":
-		hudImportData=fpdb_simple.generateHudCacheData(playerIDs, base, category, actionTypes, allIns, actionTypeByNo, winnings, totalWinnings, positions)
-	else:
-		hudImportData=fpdb_simple.generateHudCacheData(playerIDs, base, category, actionTypes, allIns, actionTypeByNo, winnings, totalWinnings, None)
-	
-	if isTourney:
-		ranks=[]
-		for i in range (len(names)):
-			ranks.append(0)
-		payin_amounts=fpdb_simple.calcPayin(len(names), buyin, fee)
-		
-		if base=="hold":
-			result = fpdb_save_to_db.tourney_holdem_omaha(cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries, prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteID,
-					siteHandNo, gametypeID, handStartTime, names, playerIDs, startCashes, positions, cardValues, cardSuits, boardValues, boardSuits, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, hudImportData, maxSeats, tableName, seatNos)
-		elif base=="stud":
-			result = fpdb_save_to_db.tourney_stud(cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries, prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteID,
-					siteHandNo, gametypeID, handStartTime, names, playerIDs, startCashes, antes, cardValues, cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, hudImportData, maxSeats, tableName, seatNos)
-		else:
-			raise fpdb_simple.FpdbError ("unrecognised category")
-	else:
-		if base=="hold":
-			result = fpdb_save_to_db.ring_holdem_omaha(cursor, base, category, siteHandNo, gametypeID, handStartTime, names, playerIDs, startCashes, positions, cardValues, cardSuits, boardValues, boardSuits, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, hudImportData, maxSeats, tableName, seatNos)
-		elif base=="stud":
-			result = fpdb_save_to_db.ring_stud(cursor, base, category, siteHandNo, gametypeID, 
-					handStartTime, names, playerIDs, startCashes, antes, cardValues, 
-					cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, hudImportData, maxSeats, tableName, seatNos)
-		else:
-			raise fpdb_simple.FpdbError ("unrecognised category")
-		db.commit()
-	return result
+        tourneyTypeId=fpdb_simple.recogniseTourneyTypeId(cursor, siteID, buyin, fee, knockout, rebuyOrAddon)        
+    fpdb_simple.isAlreadyInDB(cursor, gametypeID, siteHandNo)
+    
+    #part 2: classify lines by type (e.g. cards, action, win, sectionchange) and street
+    fpdb_simple.classifyLines(hand, category, lineTypes, lineStreets)
+        
+    #part 3: read basic player info    
+    #3a read player names, startcashes
+    for i in range (len(hand)): #todo: use maxseats+1 here.
+        if (lineTypes[i]=="name"):
+            seatLines.append(hand[i])
+    names=fpdb_simple.parseNames(seatLines)
+    playerIDs = fpdb_simple.recognisePlayerIDs(cursor, names, siteID)
+    tmp=fpdb_simple.parseCashesAndSeatNos(seatLines, site)
+    startCashes=tmp['startCashes']
+    seatNos=tmp['seatNos']
+    
+    fpdb_simple.createArrays(category, len(names), cardValues, cardSuits, antes, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo)
+    
+    #3b read positions
+    if base=="hold":
+        positions = fpdb_simple.parsePositions (hand, names)
+    
+    #part 4: take appropriate action for each line based on linetype
+    for i in range(len(hand)):
+        if (lineTypes[i]=="cards"):
+            fpdb_simple.parseCardLine (site, category, lineStreets[i], hand[i], names, cardValues, cardSuits, boardValues, boardSuits)
+            #if category=="studhilo":
+            #    print "hand[i]:", hand[i]
+            #    print "cardValues:", cardValues
+            #    print "cardSuits:", cardSuits
+        elif (lineTypes[i]=="action"):
+            fpdb_simple.parseActionLine (site, base, isTourney, hand[i], lineStreets[i], playerIDs, names, actionTypes, allIns, actionAmounts, actionNos, actionTypeByNo)
+        elif (lineTypes[i]=="win"):
+            fpdb_simple.parseWinLine (hand[i], site, names, winnings, isTourney)
+        elif (lineTypes[i]=="rake"):
+            if isTourney:
+                totalRake=0
+            else:
+                totalRake=fpdb_simple.parseRake(hand[i])
+            fpdb_simple.splitRake(winnings, rakes, totalRake)
+        elif (lineTypes[i]=="header" or lineTypes[i]=="rake" or lineTypes[i]=="name" or lineTypes[i]=="ignore"):
+            pass
+        elif (lineTypes[i]=="ante"):
+            fpdb_simple.parseAnteLine(hand[i], site, isTourney, names, antes)
+        elif (lineTypes[i]=="table"):
+            tableResult=fpdb_simple.parseTableLine(site, base, hand[i])
+        else:
+            raise fpdb_simple.FpdbError("unrecognised lineType:"+lineTypes[i])
+    if site=="ftp":
+        tableResult=fpdb_simple.parseTableLine(site, base, hand[0])
+    maxSeats=tableResult['maxSeats']
+    tableName=tableResult['tableName']
+    #print "before part5, antes:", antes
+    
+    #part 5: final preparations, then call fpdb_save_to_db.* with
+    #         the arrays as they are - that file will fill them.
+    fpdb_simple.convertCardValues(cardValues)
+    if base=="hold":
+        fpdb_simple.convertCardValuesBoard(boardValues)
+        fpdb_simple.convertBlindBet(actionTypes, actionAmounts)
+        fpdb_simple.checkPositions(positions)
+        
+    cursor.execute("SELECT limitType FROM Gametypes WHERE id=%s",(gametypeID, ))
+    limit_type=cursor.fetchone()[0]
+    fpdb_simple.convert3B4B(site, category, limit_type, actionTypes, actionAmounts)
+    
+    totalWinnings=0
+    for i in range(len(winnings)):
+        totalWinnings+=winnings[i]
+    
+    if base=="hold":
+        hudImportData=fpdb_simple.generateHudCacheData(playerIDs, base, category, actionTypes
+                                     , allIns, actionTypeByNo, winnings, totalWinnings, positions
+                                     , actionTypes, actionAmounts)
+    else:
+        hudImportData=fpdb_simple.generateHudCacheData(playerIDs, base, category, actionTypes
+                                     , allIns, actionTypeByNo, winnings, totalWinnings, None
+                                     , actionTypes, actionAmounts)
+    
+    if isTourney:
+        ranks=[]
+        for i in range (len(names)):
+            ranks.append(0)
+        payin_amounts=fpdb_simple.calcPayin(len(names), buyin, fee)
+        
+        if base=="hold":
+            result = fpdb_save_to_db.tourney_holdem_omaha(
+                                       backend, db, cursor, base, category, siteTourneyNo, buyin
+                                     , fee, knockout, entries, prizepool, tourneyStartTime
+                                     , payin_amounts, ranks, tourneyTypeId, siteID, siteHandNo
+                                     , gametypeID, handStartTime, names, playerIDs, startCashes
+                                     , positions, cardValues, cardSuits, boardValues, boardSuits
+                                     , winnings, rakes, actionTypes, allIns, actionAmounts
+                                     , actionNos, hudImportData, maxSeats, tableName, seatNos)
+        elif base=="stud":
+            result = fpdb_save_to_db.tourney_stud(
+                                       backend, db, cursor, base, category, siteTourneyNo
+                                     , buyin, fee, knockout, entries, prizepool, tourneyStartTime
+                                     , payin_amounts, ranks, tourneyTypeId, siteID, siteHandNo
+                                     , gametypeID, handStartTime, names, playerIDs, startCashes
+                                     , antes, cardValues, cardSuits, winnings, rakes, actionTypes
+                                     , allIns, actionAmounts, actionNos, hudImportData, maxSeats
+                                     , tableName, seatNos)
+        else:
+            raise fpdb_simple.FpdbError ("unrecognised category")
+    else:
+        if base=="hold":
+            result = fpdb_save_to_db.ring_holdem_omaha(
+                                       backend, db, cursor, base, category, siteHandNo
+                                     , gametypeID, handStartTime, names, playerIDs
+                                     , startCashes, positions, cardValues, cardSuits
+                                     , boardValues, boardSuits, winnings, rakes
+                                     , actionTypes, allIns, actionAmounts, actionNos
+                                     , hudImportData, maxSeats, tableName, seatNos)
+        elif base=="stud":
+            result = fpdb_save_to_db.ring_stud(
+                                       backend, db, cursor, base, category, siteHandNo, gametypeID
+                                     , handStartTime, names, playerIDs, startCashes, antes
+                                     , cardValues, cardSuits, winnings, rakes, actionTypes, allIns
+                                     , actionAmounts, actionNos, hudImportData, maxSeats, tableName
+                                     , seatNos)
+        else:
+            raise fpdb_simple.FpdbError ("unrecognised category")
+        db.commit()
+    return result
 #end def mainParser
 
diff --git a/pyfpdb/fpdb_save_to_db.py b/pyfpdb/fpdb_save_to_db.py
index af6ab09d..3a7989ca 100644
--- a/pyfpdb/fpdb_save_to_db.py
+++ b/pyfpdb/fpdb_save_to_db.py
@@ -18,77 +18,110 @@
 #This file contains methods to store hands into the db. decides to move this
 #into a seperate file since its ugly, fairly long and just generally in the way.
 
+from time import time
+
 import fpdb_simple
 
 #stores a stud/razz hand into the database
-def ring_stud(cursor, base, category, site_hand_no, gametype_id, hand_start_time, names, player_ids, start_cashes, antes, card_values, card_suits, winnings, rakes, action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
-	fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-	
-	hands_id=fpdb_simple.storeHands(cursor, site_hand_no, gametype_id, hand_start_time, names, tableName, maxSeats)
-	
-	#print "before calling store_hands_players_stud, antes:", antes
-	hands_players_ids=fpdb_simple.store_hands_players_stud(cursor, hands_id, player_ids, 
-				start_cashes, antes, card_values, card_suits, winnings, rakes, seatNos)
-	
-	fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
-	
-	fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
-	return hands_id
+def ring_stud(backend, db, cursor, base, category, site_hand_no, gametype_id, hand_start_time
+             ,names, player_ids, start_cashes, antes, card_values, card_suits, winnings, rakes
+             ,action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName
+             ,seatNos):
+    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+    
+    hands_id=fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
+                                   ,hand_start_time, names, tableName, maxSeats)
+    
+    #print "before calling store_hands_players_stud, antes:", antes
+    hands_players_ids=fpdb_simple.store_hands_players_stud(backend, db, cursor, hands_id, player_ids
+                                                          ,start_cashes, antes, card_values
+                                                          ,card_suits, winnings, rakes, seatNos)
+    
+    fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
+    
+    fpdb_simple.storeActions(cursor, hands_players_ids, action_types
+                            ,allIns, action_amounts, actionNos)
+    return hands_id
 #end def ring_stud
 
-def ring_holdem_omaha(cursor, base, category, site_hand_no, gametype_id, hand_start_time, names, player_ids, start_cashes, positions, card_values, card_suits, board_values, board_suits, winnings, rakes, action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
-	"""stores a holdem/omaha hand into the database"""
-	fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-	fpdb_simple.fill_board_cards(board_values, board_suits)
+def ring_holdem_omaha(backend, db, cursor, base, category, site_hand_no, gametype_id
+                     ,hand_start_time, names, player_ids, start_cashes, positions, card_values
+                     ,card_suits, board_values, board_suits, winnings, rakes, action_types, allIns
+                     ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
+    """stores a holdem/omaha hand into the database"""
+    t0 = time()
+    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+    t1 = time()
+    fpdb_simple.fill_board_cards(board_values, board_suits)
+    t2 = time()
 
-	hands_id=fpdb_simple.storeHands(cursor, site_hand_no, gametype_id, hand_start_time, names, tableName, maxSeats)
-	
-	hands_players_ids=fpdb_simple.store_hands_players_holdem_omaha(cursor, category, hands_id, player_ids, start_cashes, positions, card_values, card_suits, winnings, rakes, seatNos)
-				
-	fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
-	
-	fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
-	
-	fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
-	return hands_id
+    hands_id=fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
+                                   ,hand_start_time, names, tableName, maxSeats)
+    t3 = time()
+    hands_players_ids=fpdb_simple.store_hands_players_holdem_omaha(
+                               backend, db, cursor, category, hands_id, player_ids, start_cashes
+                             , positions, card_values, card_suits, winnings, rakes, seatNos)
+    t4 = time()            
+    fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
+    t5 = time()
+    fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
+    t6 = time()
+    fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
+    t7 = time()
+    print "cards=%4.3f board=%4.3f hands=%4.3f plyrs=%4.3f hudcache=%4.3f board=%4.3f actions=%4.3f" \
+    % (t1-t0, t2-t1, t3-t2, t4-t3, t5-t4, t6-t5, t7-t6)
+    return hands_id
 #end def ring_holdem_omaha
 
-def tourney_holdem_omaha(cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries, prizepool, tourney_start, payin_amounts, ranks, tourneyTypeId, siteId, #end of tourney specific params
-			site_hand_no, gametype_id, hand_start_time, names, player_ids, start_cashes, positions, card_values, card_suits, board_values, board_suits, winnings, rakes, action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
-	"""stores a tourney holdem/omaha hand into the database"""
-	fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-	fpdb_simple.fill_board_cards(board_values, board_suits)
-	
-	tourney_id=fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourney_start)
-	tourneys_players_ids=fpdb_simple.store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings)
-	
-	hands_id=fpdb_simple.storeHands(cursor, site_hand_no, gametype_id, hand_start_time, names, tableName, maxSeats)
-	
-	hands_players_ids=fpdb_simple.store_hands_players_holdem_omaha_tourney(cursor, category, hands_id, player_ids, start_cashes, positions, card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids)
-	
-	fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
-	
-	fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
-	
-	fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
-	return hands_id
+def tourney_holdem_omaha(backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout
+                        ,entries, prizepool, tourney_start, payin_amounts, ranks, tourneyTypeId
+                        ,siteId #end of tourney specific params
+                        ,site_hand_no, gametype_id, hand_start_time, names, player_ids
+                        ,start_cashes, positions, card_values, card_suits, board_values
+                        ,board_suits, winnings, rakes, action_types, allIns, action_amounts
+                        ,actionNos, hudImportData, maxSeats, tableName, seatNos):
+    """stores a tourney holdem/omaha hand into the database"""
+    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+    fpdb_simple.fill_board_cards(board_values, board_suits)
+    
+    tourney_id=fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourney_start)
+    tourneys_players_ids=fpdb_simple.store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings)
+    
+    hands_id=fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
+                                   ,hand_start_time, names, tableName, maxSeats)
+    
+    hands_players_ids=fpdb_simple.store_hands_players_holdem_omaha_tourney(
+                      backend, db, cursor, category, hands_id, player_ids, start_cashes, positions
+                    , card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids)
+    
+    fpdb_simple.storeHudCache(cursor, base, category, gametype_id, player_ids, hudImportData)
+    
+    fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
+    
+    fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
+    return hands_id
 #end def tourney_holdem_omaha
 
-def tourney_stud(cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries, prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteId,
-					siteHandNo, gametypeId, handStartTime, names, playerIds, startCashes, antes, cardValues, cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
+def tourney_stud(backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries
+                ,prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteId
+                ,siteHandNo, gametypeId, handStartTime, names, playerIds, startCashes, antes
+                ,cardValues, cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts
+                ,actionNos, hudImportData, maxSeats, tableName, seatNos):
 #stores a tourney stud/razz hand into the database
-	fpdb_simple.fillCardArrays(len(names), base, category, cardValues, cardSuits)
-	
-	tourney_id=fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourneyStartTime)
-	
-	tourneys_players_ids=fpdb_simple.store_tourneys_players(cursor, tourney_id, playerIds, payin_amounts, ranks, winnings)
-	
-	hands_id=fpdb_simple.storeHands(cursor, siteHandNo, gametypeId, handStartTime, names, tableName, maxSeats)
-	
-	hands_players_ids=fpdb_simple.store_hands_players_stud_tourney(cursor, hands_id, playerIds, startCashes, antes, cardValues, cardSuits, winnings, rakes, seatNos, tourneys_players_ids)
-	
-	fpdb_simple.storeHudCache(cursor, base, category, gametypeId, playerIds, hudImportData)
-	
-	fpdb_simple.storeActions(cursor, hands_players_ids, actionTypes, allIns, actionAmounts, actionNos)
-	return hands_id
+    fpdb_simple.fillCardArrays(len(names), base, category, cardValues, cardSuits)
+    
+    tourney_id=fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourneyStartTime)
+    
+    tourneys_players_ids=fpdb_simple.store_tourneys_players(cursor, tourney_id, playerIds, payin_amounts, ranks, winnings)
+    
+    hands_id=fpdb_simple.storeHands(backend, db, cursor, siteHandNo, gametypeId, handStartTime, names, tableName, maxSeats)
+    
+    hands_players_ids=fpdb_simple.store_hands_players_stud_tourney(backend, db, cursor, hands_id
+                                             , playerIds, startCashes, antes, cardValues, cardSuits
+                                             , winnings, rakes, seatNos, tourneys_players_ids)
+    
+    fpdb_simple.storeHudCache(cursor, base, category, gametypeId, playerIds, hudImportData)
+    
+    fpdb_simple.storeActions(cursor, hands_players_ids, actionTypes, allIns, actionAmounts, actionNos)
+    return hands_id
 #end def tourney_stud
diff --git a/pyfpdb/fpdb_simple.py b/pyfpdb/fpdb_simple.py
old mode 100644
new mode 100755
index 30831b83..dd7d56e8
--- a/pyfpdb/fpdb_simple.py
+++ b/pyfpdb/fpdb_simple.py
@@ -1,2160 +1,2217 @@
-#!/usr/bin/python
-
-#Copyright 2008 Steffen Jobbagy-Felso
-#This program is free software: you can redistribute it and/or modify
-#it under the terms of the GNU Affero General Public License as published by
-#the Free Software Foundation, version 3 of the License.
-#
-#This program is distributed in the hope that it will be useful,
-#but WITHOUT ANY WARRANTY; without even the implied warranty of
-#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-#GNU General Public License for more details.
-#
-#You should have received a copy of the GNU Affero General Public License
-#along with this program. If not, see <http://www.gnu.org/licenses/>.
-#In the "official" distribution you can find the license in
-#agpl-3.0.txt in the docs folder of the package.
-
-#This file contains simple functions for fpdb
-
-import datetime
-import re
-
-PS=1
-FTP=2
-
-class DuplicateError(Exception):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class FpdbError(Exception):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-#returns an array of the total money paid. intending to add rebuys/addons here
-def calcPayin(count, buyin, fee):
-	result=[]
-	for i in range(count):
-		result.append (buyin+fee)
-	return result
-#end def calcPayin
-
-def checkPositions(positions):
-	"""verifies that these positions are valid"""
-	for i in range (len(positions)):
-		pos=positions[i]
-		try:#todo: use type recognition instead of error
-			if (len(pos)!=1):
-				raise FpdbError("invalid position found in checkPositions. i: "+str(i)+"   position: "+pos) #dont need to str() here
-		except TypeError:#->not string->is int->fine
-			pass
-		
-		### RHH modified to allow for "position 9" here (pos==9 is when you're a dead hand before the BB
-		### eric - position 8 could be valid - if only one blind is posted, but there's still 10 people, ie a sitout is present, and the small is dead...
-		if not (pos == "B" or pos == "S" or (pos >= 0 and pos <= 9)):
-			raise FpdbError("invalid position found in checkPositions. i: "+str(i)+"   position: "+str(pos))
-#end def fpdb_simple.checkPositions
-
-#classifies each line for further processing in later code. Manipulates the passed arrays.
-def classifyLines(hand, category, lineTypes, lineStreets):
-	currentStreet="predeal"
-	done=False #set this to true once we reach the last relevant line (the summary, except rake, is all repeats)
-	for i in range (len(hand)):
-		if (done):
-			if (hand[i].find("[")==-1 or hand[i].find("mucked [")==-1):
-				lineTypes.append("ignore")
-			else: #it's storing a mucked card
-				lineTypes.append("cards")
-		elif (hand[i].startswith("Dealt to")):
-			lineTypes.append("cards")
-		elif (i==0):
-			lineTypes.append("header")
-		elif (hand[i].startswith("Seat ") and ((hand[i].find("in chips")!=-1) or (hand[i].find("($")!=-1))):
-			lineTypes.append("name")
-		elif (isActionLine(hand[i])):
-			lineTypes.append("action")
-			if (hand[i].find(" posts ")!=-1 or hand[i].find(" posts the ")!=-1):#need to set this here so the "action" of posting blinds is registered properly
-				currentStreet="preflop"
-		elif (isWinLine(hand[i])):
-			lineTypes.append("win")
-		elif (hand[i].startswith("Total pot ") and hand[i].find("Rake")!=-1):
-			lineTypes.append("rake")
-			done=True
-		elif (hand[i]=="*** SHOW DOWN ***" or hand[i]=="*** SUMMARY ***"):
-			lineTypes.append("ignore")
-			#print "in classifyLine, showdown or summary"
-		elif (hand[i].find(" antes ")!=-1 or hand[i].find(" posts the ante ")!=-1):
-			lineTypes.append("ante")
-		elif (hand[i].startswith("*** FLOP *** [")):
-			lineTypes.append("cards")
-			currentStreet="flop"
-		elif (hand[i].startswith("*** TURN *** [")):
-			lineTypes.append("cards")
-			currentStreet="turn"
-		elif (hand[i].startswith("*** RIVER *** [")):
-			lineTypes.append("cards")
-			currentStreet="river"
-		elif (hand[i].startswith("*** 3")):
-			lineTypes.append("ignore")
-			currentStreet=0
-		elif (hand[i].startswith("*** 4")):
-			lineTypes.append("ignore")
-			currentStreet=1
-		elif (hand[i].startswith("*** 5")):
-			lineTypes.append("ignore")
-			currentStreet=2
-		elif (hand[i].startswith("*** 6")):
-			lineTypes.append("ignore")
-			currentStreet=3
-		elif (hand[i].startswith("*** 7") or hand[i]=="*** RIVER ***"):
-			lineTypes.append("ignore")
-			currentStreet=4
-		elif (hand[i].find(" shows [")!=-1):
-			lineTypes.append("cards")
-		elif (hand[i].startswith("Table '")):
-			lineTypes.append("table")
-		else:
-			raise FpdbError("unrecognised linetype in:"+hand[i])
-		lineStreets.append(currentStreet)
-#end def classifyLines
-
-def convert3B4B(site, category, limit_type, actionTypes, actionAmounts):
-	"""calculates the actual bet amounts in the given amount array and changes it accordingly."""
-	for i in range (len(actionTypes)):
-		for j in range (len(actionTypes[i])):
-			bets=[]
-			for k in range (len(actionTypes[i][j])):
-				if (actionTypes[i][j][k]=="bet"):
-					bets.append((i,j,k))
-					if (len(bets)==2):
-						#print "len(bets) 2 or higher, need to correct it. bets:",bets,"len:",len(bets)
-						amount2=actionAmounts[bets[1][0]][bets[1][1]][bets[1][2]]
-						amount1=actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]
-						actionAmounts[bets[1][0]][bets[1][1]][bets[1][2]]=amount2-amount1
-					elif (len(bets)>2):
-						fail=True
-						#todo: run correction for below
-						if (site=="ps" and category=="holdem" and limit_type=="nl" and len(bets)==3):
-							fail=False
-						if (site=="ftp" and category=="omahahi" and limit_type=="pl" and len(bets)==3):
-							fail=False
-						
-						if fail:
-							print "len(bets)>2 in convert3B4B, i didnt think this is possible. i:",i,"j:",j,"k:",k
-							print "actionTypes:",actionTypes
-							raise FpdbError ("too many bets in convert3B4B")
-	#print "actionAmounts postConvert",actionAmounts
-#end def convert3B4B(actionTypes, actionAmounts)
-
-#Corrects the bet amount if the player had to pay blinds
-def convertBlindBet(actionTypes, actionAmounts):
-	i=0#setting street to pre-flop
-	for j in range (len(actionTypes[i])):#playerloop
-		blinds=[]
-		bets=[]
-		for k in range (len(actionTypes[i][j])):
-			if (actionTypes[i][j][k]=="blind"):
-				blinds.append((i,j,k))
-			
-			if (len(blinds)>0 and actionTypes[i][j][k]=="bet"):
-				bets.append((i,j,k))
-				if (len(bets)==1):
-					blind_amount=actionAmounts[blinds[0][0]][blinds[0][1]][blinds[0][2]]
-					bet_amount=actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]
-					actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]=bet_amount-blind_amount
-#end def convertBlindBet
-
-#converts the strings in the given array to ints (changes the passed array, no returning). see table design for conversion details
-#todo: make this use convertCardValuesBoard
-def convertCardValues(arr):
-	for i in range (len(arr)):
-		for j in range (len(arr[i])):
-			if (arr[i][j]=="A"):
-				arr[i][j]=14
-			elif (arr[i][j]=="K"):
-				arr[i][j]=13
-			elif (arr[i][j]=="Q"):
-				arr[i][j]=12
-			elif (arr[i][j]=="J"):
-				arr[i][j]=11
-			elif (arr[i][j]=="T"):
-				arr[i][j]=10
-			else:
-				arr[i][j]=int(arr[i][j])
-#end def convertCardValues
-
-#converts the strings in the given array to ints (changes the passed array, no returning). see table design for conversion details
-def convertCardValuesBoard(arr):
-	for i in range (len(arr)):
-		if (arr[i]=="A"):
-			arr[i]=14
-		elif (arr[i]=="K"):
-			arr[i]=13
-		elif (arr[i]=="Q"):
-			arr[i]=12
-		elif (arr[i]=="J"):
-			arr[i]=11
-		elif (arr[i]=="T"):
-			arr[i]=10
-		else:
-			arr[i]=int(arr[i])
-#end def convertCardValuesBoard
-
-#this creates the 2D/3D arrays. manipulates the passed arrays instead of returning.
-def createArrays(category, seats, card_values, card_suits, antes, winnings, rakes, action_types, allIns, action_amounts, actionNos, actionTypeByNo):
-	for i in range(seats):#create second dimension arrays
-		tmp=[]
-		card_values.append(tmp)
-		tmp=[]
-		card_suits.append(tmp)
-		antes.append(0)
-		winnings.append(0)
-		rakes.append(0)
-	
-	if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
-		streetCount=4
-	else:
-		streetCount=5
-	
-	for i in range(streetCount): #build the first dimension array, for streets 
-		tmp=[]
-		action_types.append(tmp)
-		tmp=[]
-		allIns.append(tmp)
-		tmp=[]
-		action_amounts.append(tmp)
-		tmp=[]
-		actionNos.append(tmp)
-		tmp=[]
-		actionTypeByNo.append(tmp)
-		for j in range (seats): #second dimension arrays: players
-			tmp=[]
-			action_types[i].append(tmp)
-			tmp=[]
-			allIns[i].append(tmp)
-			tmp=[]
-			action_amounts[i].append(tmp)
-			tmp=[]
-			actionNos[i].append(tmp)
-	if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
-		pass
-	elif (category=="razz" or category=="studhi" or category=="studhilo"):#need to fill card arrays.
-		for i in range(seats):
-			for j in range (7):
-				card_values[i].append(0)
-				card_suits[i].append("x")
-	else:
-		raise FpdbError("invalid category")
-#end def createArrays
-
-def fill_board_cards(board_values, board_suits):
-#fill up the two board card arrays
-	while (len(board_values)<5):
-		board_values.append(0)
-		board_suits.append("x")
-#end def fill_board_cards
-
-def fillCardArrays(player_count, base, category, card_values, card_suits):
-	"""fills up the two card arrays"""
-	if (category=="holdem"):
-		cardCount=2
-	elif (category=="omahahi" or category=="omahahilo"):
-		cardCount=4
-	elif base=="stud":
-		cardCount=7
-	else:
-		raise fpdb_simple.FpdbError ("invalid category:", category)
-	
-	for i in range (player_count):
-		while (len(card_values[i])<cardCount):
-			card_values[i].append(0)
-			card_suits[i].append("x")
-#end def fillCardArrays
-
-#filters out a player that folded before paying ante or blinds. This should be called
-#before calling the actual hand parser. manipulates hand, no return.
-def filterAnteBlindFold(site,hand):
-	#todo: this'll only get rid of one ante folder, not multiple ones
-	#todo: in tourneys this should not be removed but 
-	#print "start of filterAnteBlindFold"
-	pre3rd=[]
-	for i in range (len(hand)):
-		if (hand[i].startswith("*** 3") or hand[i].startswith("*** HOLE")):
-			pre3rd=hand[0:i]
-	
-	foldeeName=None
-	for i in range (len(pre3rd)):
-		if (pre3rd[i].endswith("folds") or pre3rd[i].endswith("is sitting out") or pre3rd[i].endswith(" stands up")): #found ante fold or timeout
-			pos=pre3rd[i].find (" folds")
-			foldeeName=pre3rd[i][0:pos]
-			if pos==-1 and pre3rd[i].find(" in chips)")==-1:
-				pos=pre3rd[i].find (" is sitting out")
-				foldeeName=pre3rd[i][0:pos]
-			if pos==-1:
-				pos=pre3rd[i].find (" stands up")
-				foldeeName=pre3rd[i][0:pos]
-			if pos==-1:#this one is for PS tourney
-				pos1=pre3rd[i].find (": ")+2
-				pos2=pre3rd[i].find (" (")
-				foldeeName=pre3rd[i][pos1:pos2]
-
-	if foldeeName!=None:
-		#print "filterAnteBlindFold, foldeeName:",foldeeName
-		toRemove=[]
-		for i in range (len(hand)): #using hand again to filter from all streets, just in case.
-			#todo: this will break it if sittin out BB wins a hand
-			if (hand[i].find(foldeeName)!=-1):
-				toRemove.append(hand[i])
-			
-		for i in range (len(toRemove)):
-			hand.remove(toRemove[i])
-#end def filterAnteFold
-
-#removes useless lines as well as trailing spaces
-def filterCrap(site, hand, isTourney):
-	#remove two trailing spaces at end of line
-	for i in range (len(hand)):
-		if (hand[i][-1]==' '):
-			hand[i]=hand[i][:-1]
-		if (hand[i][-1]==' '):
-			hand[i]=hand[i][:-1]
-			
-	#print "hand after trailing space removal in filterCrap:",hand
-	#general variable position word filter/string filter
-	toRemove=[]
-	for i in range (len(hand)):
-		if (hand[i].startswith("Board [")):
-			toRemove.append(hand[i])
-		elif (hand[i].find(" out of hand ")!=-1):
-			hand[i]=hand[i][:-56]
-		elif (hand[i].find("($0 in chips)") != -1):
-			toRemove.append(hand[i])			
-		elif (hand[i]=="*** HOLE CARDS ***"):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has been disconnected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has requested TIME")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has returned")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("will be allowed to play after the button")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has timed out")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has timed out while disconnected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has timed out while being disconnected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("is connected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("is disconnected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" is feeling angry")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" is feeling confused")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" is feeling happy")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" is feeling normal")):
-			toRemove.append(hand[i])
-		elif (hand[i].find(" is low with [")!=-1):
-			toRemove.append(hand[i])
-		#elif (hand[i].find("-max Seat #")!=-1 and hand[i].find(" is the button")!=-1):
-		#	toRemove.append(hand[i])
-		elif (hand[i].endswith(" mucks")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(": mucks hand")):
-			toRemove.append(hand[i])
-		elif (hand[i]=="No low hand qualified"):
-			toRemove.append(hand[i])
-		elif (hand[i]=="Pair on board - a double bet is allowed"):
-			toRemove.append(hand[i])
-		elif (hand[i].find(" shows ")!=-1 and hand[i].find("[")==-1):
-			toRemove.append(hand[i])
-		#elif (hand[i].startswith("Table '") and hand[i].endswith("-max")):
-		#	toRemove.append(hand[i])
-		elif (hand[i].startswith("The button is in seat #")):
-			toRemove.append(hand[i])
-		#above is alphabetic, reorder below if bored
-		elif (hand[i].startswith("Time has expired")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("has reconnected")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("seconds left to act")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("seconds to reconnect")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("was removed from the table for failing to post")):
-			toRemove.append(hand[i])
-		elif (hand[i].find("joins the table at seat ")!=-1):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" sits down")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("leaves the table")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith(" stands up")):
-			toRemove.append(hand[i])
-		elif (hand[i].find("is high with ")!=-1):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("doesn't show hand")):
-			toRemove.append(hand[i])
-		elif (hand[i].endswith("is being treated as all-in")):
-			toRemove.append(hand[i])
-		elif (hand[i].find(" adds $")!=-1):
-			toRemove.append(hand[i])
-		elif (hand[i]=="Betting is capped"):
-			toRemove.append(hand[i])
-		#site specific variable position filter
-		elif (hand[i].find(" said, \"")!=-1):
-			toRemove.append(hand[i])
-		elif (hand[i].find(": ")!=-1 and site=="ftp" and hand[i].find("Seat ")==-1 and hand[i].find(": Table")==-1): #filter ftp chat
-			toRemove.append(hand[i])
-		if isTourney:
-			if (hand[i].endswith(" is sitting out") and (not hand[i].startswith("Seat "))):
-				toRemove.append(hand[i])
-		else:
-			if (hand[i].endswith(": sits out")):
-				toRemove.append(hand[i])
-			elif (hand[i].endswith(" is sitting out")):
-				toRemove.append(hand[i])
-
-	
-	for i in range (len(toRemove)):
-		#print "removing in filterCr:",toRemove[i]
-		hand.remove(toRemove[i])
-	
-	#print "done with filterCrap, hand:", hand
-	return hand
-#end filterCrap
-
-#takes a poker float (including , for thousand seperator and converts it to an int
-def float2int (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:]
-	
-	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
-
-#returns boolean whether the passed line is an action line
-def isActionLine(line):
-	if (line.endswith("folds")):
-		return True
-	elif (line.endswith("checks")):
-		return True
-	elif (line.find("calls $")!=-1 or line.find(": calls ")!=-1):
-		return True
-	elif (line.find("brings in for")!=-1):
-		return True
-	elif (line.find("completes it to")!=-1):
-		return True
-	elif (line.find("posts small blind")!=-1):
-		return True
-	elif (line.find("posts the small blind")!=-1):
-		return True
-	elif (line.find("posts big blind")!=-1):
-		return True
-	elif (line.find("posts the big blind")!=-1):
-		return True
-	elif (line.find("posts small & big blinds")!=-1):
-		return True
-	elif (line.find(" posts $")!=-1): #this reads voluntary blind pay in FTP Holdem
-		return True
-	elif (line.find(" posts a dead ")!=-1): #this reads voluntary blind pay in FTP Holdem
-		return True
-	elif (line.find("bets $")!=-1 or line.find(": bets ")!=-1):
-		return True
-	elif (line.find("raises")!=-1):
-		return True
-	elif (line.startswith("Uncalled bet")):
-		return True
-	else:
-		return False
-#end def isActionLine
-
-#returns whether this is a duplicate
-def isAlreadyInDB(cursor, gametypeID, siteHandNo):
-	cursor.execute ("SELECT id FROM Hands WHERE gametypeId=%s AND siteHandNo=%s", (gametypeID, siteHandNo))
-	result=cursor.fetchall()
-	if (len(result)>=1):
-		raise DuplicateError ("dupl")
-#end isAlreadyInDB
-
-def isRebuyOrAddon(topline):
-	"""isRebuyOrAddon not implemented yet"""
-	return False
-#end def isRebuyOrAddon
-
-#returns whether the passed topline indicates a tournament or not
-def isTourney(topline):
-	if (topline.find("Tournament")!=-1):
-		return True
-	else:
-		return False
-#end def isTourney
-
-#returns boolean whether the passed line is a win line
-def isWinLine(line):
-	if (line.find("wins the pot")!=-1):
-		return True
-	elif (line.find("ties for the high pot")!=-1):
-		return True
-	elif (line.find("ties for the high main pot")!=-1):
-		return True
-	elif (line.find("ties for the high side pot")!=-1):
-		return True
-	elif (line.find("ties for the low pot")!=-1):
-		return True
-	elif (line.find("ties for the low main pot")!=-1):
-		return True
-	elif (line.find("ties for the low side pot")!=-1):
-		return True
-	elif (line.find("ties for the main pot")!=-1): #for ftp tied main pot of split pot
-		return True
-	elif (line.find("ties for the pot")!=-1): #for ftp tie
-		return True
-	elif (line.find("ties for the side pot")!=-1): #for ftp tied split pots
-		return True
-	elif (line.find("wins side pot #")!=-1): #for ftp multi split pots
-		return True
-	elif (line.find("wins the low main pot")!=-1):
-		return True
-	elif (line.find("wins the low pot")!=-1):
-		return True
-	elif (line.find("wins the low side pot")!=-1):
-		return True
-	elif (line.find("wins the high main pot")!=-1):
-		return True
-	elif (line.find("wins the high pot")!=-1):
-		return True
-	elif (line.find("wins the high side pot")!=-1):
-		return True
-	elif (line.find("wins the main pot")!=-1):
-		return True
-	elif (line.find("wins the side pot")!=-1): #for ftp split pots
-		return True
-	elif (line.find("collected")!=-1):
-		return True
-	else:
-		return False #not raising error here, any unknown line wouldve been detected in isActionLine already
-#end def isWinLine
-
-#returns the amount of cash/chips put into the put in the given action line
-def parseActionAmount(line, atype, site, isTourney):
-	#if (line.endswith(" and is all-in")):
-	#	line=line[:-14]
-	#elif (line.endswith(", and is all in")):
-	#	line=line[:-15]
-	
-	if line.endswith(", and is capped"):#ideally we should recognise this as an all-in if category is capXl
-		line=line[:-15]
-	if line.endswith(" and is capped"):
-		line=line[:-14]
-
-	
-	if (atype=="fold"):
-		amount=0
-	elif (atype=="check"):
-		amount=0
-	elif (atype=="unbet" and site=="ftp"):
-		pos1=line.find("$")+1
-		pos2=line.find(" returned to")
-		amount=float2int(line[pos1:pos2])
-	elif (atype=="unbet" and site=="ps"):
-		#print "ps unbet, line:",line
-		pos1=line.find("$")+1
-		if pos1==0:
-			pos1=line.find("(")+1
-		pos2=line.find(")")
-		amount=float2int(line[pos1:pos2])
-	elif (atype=="bet" and site=="ps" and line.find(": raises $")!=-1 and line.find("to $")!=-1):
-		pos=line.find("to $")+4
-		amount=float2int(line[pos:])
-	else:
-		if not isTourney:
-			pos=line.rfind("$")+1
-			#print "parseActionAmount, line:", line, "line[pos:]:", line[pos:]
-			amount=float2int(line[pos:])
-		else:
-			#print "line:"+line+"EOL"
-			pos=line.rfind(" ")+1
-			#print "pos:",pos
-			#print "pos of 20:", line.find("20")
-			amount=int(line[pos:])
-	
-	if atype=="unbet":
-		amount*=-1
-	return amount
-#end def parseActionAmount
-
-#doesnt return anything, simply changes the passed arrays action_types and
-#	action_amounts. For stud this expects numeric streets (3-7), for
-#	holdem/omaha it expects predeal, preflop, flop, turn or river
-def parseActionLine(site, base, isTourney, line, street, playerIDs, names, action_types, allIns, action_amounts, actionNos, actionTypeByNo):
-	if (street=="predeal" or street=="preflop"):
-		street=0
-	elif (street=="flop"):
-		street=1
-	elif (street=="turn"):
-		street=2
-	elif (street=="river"):
-		street=3
-	
-	nextActionNo=0
-	for player in range(len(actionNos[street])):
-		for count in range(len(actionNos[street][player])):
-			if actionNos[street][player][count]>=nextActionNo:
-				nextActionNo=actionNos[street][player][count]+1
-				
-	line, allIn=goesAllInOnThisLine(line)
-	atype=parseActionType(line)
-	playerno=recognisePlayerNo(line, names, atype)
-	amount=parseActionAmount(line, atype, site, isTourney)
-	
-	action_types[street][playerno].append(atype)
-	allIns[street][playerno].append(allIn)
-	action_amounts[street][playerno].append(amount)
-	actionNos[street][playerno].append(nextActionNo)
-	tmp=(playerIDs[playerno], atype)
-	actionTypeByNo[street].append(tmp)
-#end def parseActionLine
-
-def goesAllInOnThisLine(line):
-	"""returns whether the player went all-in on this line and removes the all-in text from the line."""
-	isAllIn=False
-	if (line.endswith(" and is all-in")):
-		line=line[:-14]
-		isAllIn=True
-	elif (line.endswith(", and is all in")):
-		line=line[:-15]
-		isAllIn=True
-	return (line, isAllIn)
-#end def goesAllInOnThisLine
-
-#returns the action type code (see table design) of the given action line
-def parseActionType(line):
-	if (line.startswith("Uncalled bet")):
-		return "unbet"
-	elif (line.endswith("folds")):
-		return "fold"
-	elif (line.endswith("checks")):
-		return "check"
-	elif (line.find("calls")!=-1):
-		return "call"
-	elif (line.find("brings in for")!=-1):
-		return "blind"
-	elif (line.find("completes it to")!=-1):
-		return "bet"
-	   #todo: what if someone completes instead of bringing in?
-	elif (line.find(" posts $")!=-1):
-		return "blind"
-	elif (line.find(" posts a dead ")!=-1):
-		return "blind"
-	elif (line.find(": posts small blind ")!=-1):
-		return "blind"
-	elif (line.find(" posts the small blind of $")!=-1):
-		return "blind"
-	elif (line.find(": posts big blind ")!=-1):
-		return "blind"
-	elif (line.find(" posts the big blind of $")!=-1):
-		return "blind"
-	elif (line.find(": posts small & big blinds $")!=-1):
-		return "blind"
-	#todo: seperately record voluntary blind payments made to join table out of turn
-	elif (line.find("bets")!=-1):
-		return "bet"
-	elif (line.find("raises")!=-1):
-		return "bet"
-	else:
-		raise FpdbError ("failed to recognise actiontype in parseActionLine in: "+line)
-#end def parseActionType
-
-#parses the ante out of the given line and checks which player paid it, updates antes accordingly.
-def parseAnteLine(line, site, isTourney, names, antes):
-	for i in range(len(names)):
-		if (line.startswith(names[i].encode("latin-1"))): #found the ante'er
-			pos=line.rfind("$")+1
-			if not isTourney:
-				antes[i]+=float2int(line[pos:])
-			else:
-				if line.find("all-in")==-1:
-					pos=line.rfind(" ")+1
-					antes[i]+=int(line[pos:])
-				else:
-					pos1=line.rfind("ante")+5
-					pos2=line.find(" ",pos1)
-					antes[i]+=int(line[pos1:pos2])
-		#print "parseAnteLine line: ", line, "antes[i]", antes[i], "antes", antes
-#end def parseAntes
-
-#returns the buyin of a tourney in cents
-def parseBuyin(topline):
-	pos1=topline.find("$")+1
-	pos2=topline.find("+")
-	return float2int(topline[pos1:pos2])
-#end def parseBuyin
-
-#parses a card line and changes the passed arrays accordingly
-#todo: reorganise this messy method
-def parseCardLine(site, category, street, line, names, cardValues, cardSuits, boardValues, boardSuits):
-	if (line.startswith("Dealt to ") or line.find(" shows [")!=-1 or line.find("mucked [")!=-1):
-		playerNo=recognisePlayerNo(line, names, "card") #anything but unbet will be ok for that string
-
-		pos=line.rfind("[")+1
-		if (category=="holdem"):
-			for i in (pos, pos+3):
-				cardValues[playerNo].append(line[i:i+1])
-				cardSuits[playerNo].append(line[i+1:i+2])
-			if (len(cardValues[playerNo])!=2):
-				if cardValues[playerNo][0]==cardValues[playerNo][2] and cardSuits[playerNo][1]==cardSuits[playerNo][3]: #two tests will do
-					cardValues[playerNo]=cardValues[playerNo][0:2]
-					cardSuits[playerNo]=cardSuits[playerNo][0:2]
-				else:
-					print "line:",line,"cardValues[playerNo]:",cardValues[playerNo]
-					raise FpdbError("read too many/too few holecards in parseCardLine")
-		elif (category=="omahahi" or category=="omahahilo"):
-			for i in (pos, pos+3, pos+6, pos+9):
-				cardValues[playerNo].append(line[i:i+1])
-				cardSuits[playerNo].append(line[i+1:i+2])
-			if (len(cardValues[playerNo])!=4):
-				if cardValues[playerNo][0]==cardValues[playerNo][4] and cardSuits[playerNo][3]==cardSuits[playerNo][7]: #two tests will do
-					cardValues[playerNo]=cardValues[playerNo][0:4]
-					cardSuits[playerNo]=cardSuits[playerNo][0:4]
-				else:
-					print "line:",line,"cardValues[playerNo]:",cardValues[playerNo]
-					raise FpdbError("read too many/too few holecards in parseCardLine")
-		elif (category=="razz" or category=="studhi" or category=="studhilo"):
-			if (line.find("shows")==-1 and line.find("mucked") == -1):
-				#print "parseCardLine(in stud if), street:", street
-				if line[pos+2]=="]": #-> not (hero and 3rd street)
-					cardValues[playerNo][street+2]=line[pos:pos+1]
-					cardSuits[playerNo][street+2]=line[pos+1:pos+2]
-				else:
-					#print "hero card1:", line[pos:pos+2], "hero card2:", line[pos+3:pos+5], "hero card3:", line[pos+6:pos+8], 
-					cardValues[playerNo][street]=line[pos:pos+1]
-					cardSuits[playerNo][street]=line[pos+1:pos+2]
-					cardValues[playerNo][street+1]=line[pos+3:pos+4]
-					cardSuits[playerNo][street+1]=line[pos+4:pos+5]
-					cardValues[playerNo][street+2]=line[pos+6:pos+7]
-					cardSuits[playerNo][street+2]=line[pos+7:pos+8]
-			else:
-				#print "parseCardLine(in stud else), street:", street
-				cardValues[playerNo][0]=line[pos:pos+1]
-				cardSuits[playerNo][0]=line[pos+1:pos+2]
-				pos+=3
-				cardValues[playerNo][1]=line[pos:pos+1]
-				cardSuits[playerNo][1]=line[pos+1:pos+2]
-				if street==4:
-					pos=pos=line.rfind("]")-2
-					cardValues[playerNo][6]=line[pos:pos+1]
-					cardSuits[playerNo][6]=line[pos+1:pos+2]
-					#print "cardValues:", cardValues
-					#print "cardSuits:", cardSuits
-		else:
-			print "line:",line,"street:",street
-			raise FpdbError("invalid category")
-		#print "end of parseCardLine/playercards, cardValues:",cardValues
-	elif (line.startswith("*** FLOP ***")):
-		pos=line.find("[")+1
-		for i in (pos, pos+3, pos+6):
-			boardValues.append(line[i:i+1])
-			boardSuits.append(line[i+1:i+2])
-		#print boardValues
-	elif (line.startswith("*** TURN ***") or line.startswith("*** RIVER ***")):
-		pos=line.find("[")+1
-		pos=line.find("[", pos+1)+1
-		boardValues.append(line[pos:pos+1])
-		boardSuits.append(line[pos+1:pos+2])
-		#print boardValues
-	else:
-		raise FpdbError ("unrecognised line:"+line)
-#end def parseCardLine
-
-def parseCashesAndSeatNos(lines, site):
-	"""parses the startCashes and seatNos of each player out of the given lines and returns them as a dictionary of two arrays"""
-	cashes = []
-	seatNos = []
-	for i in range (len(lines)):
-		pos2=lines[i].find(":")
-		seatNos.append(int(lines[i][5:pos2]))
-		
-		pos1=lines[i].rfind("($")+2
-		if pos1==1: #for tourneys - it's 1 instead of -1 due to adding 2 above
-			pos1=lines[i].rfind("(")+1
-		if (site=="ftp"):
-			pos2=lines[i].rfind(")")
-		elif (site=="ps"):
-			pos2=lines[i].find(" in chips")
-		cashes.append(float2int(lines[i][pos1:pos2]))
-	return {'startCashes':cashes, 'seatNos':seatNos}
-#end def parseCashesAndSeatNos
-
-#returns the buyin of a tourney in cents
-def parseFee(topline):
-	pos1=topline.find("$")+1
-	pos1=topline.find("$",pos1)+1
-	pos2=topline.find(" ", pos1)
-	return float2int(topline[pos1:pos2])
-#end def parsefee
-
-#returns a datetime object with the starttime indicated in the given topline
-def parseHandStartTime(topline, site):
-	#convert x:13:35 to 0x:13:35
-	counter=0
-	while (True): 
-		pos=topline.find(" "+str(counter)+":")
-		if (pos!=-1): 
-			topline=topline[0:pos+1]+"0"+topline[pos+1:]
-		counter+=1
-		if counter==10: break
-	
-	isUTC=False
-	if site=="ftp":
-		pos = topline.find(" ", len(topline)-26)+1
-		tmp = topline[pos:]
-		#print "year:", tmp[14:18], "month", tmp[19:21], "day", tmp[22:24], "hour", tmp[0:2], "minute", tmp[3:5], "second", tmp[6:8]
-		result = datetime.datetime(int(tmp[14:18]), int(tmp[19:21]), int(tmp[22:24]), int(tmp[0:2]), int(tmp[3:5]), int(tmp[6:8]))
-	elif site=="ps":
-		if topline.find("UTC")!=-1:
-			pos1 = topline.find("-")+2
-			pos2 = topline.find("UTC")
-			tmp=topline[pos1:pos2]
-			isUTC=True
-		else:
-			tmp=topline
-		#	print "parsehandStartTime, tmp:", tmp
-			pos = tmp.find("-")+2
-			tmp = tmp[pos:]
-		#Need to match either
-		# 2008/09/07 06:23:14 ET or
-		# 2008/08/17 - 01:14:43 (ET) or
-		# 2008/11/12 9:33:31 CET [2008/11/12 3:33:31 ET]
-		rexx = '(?P<YEAR>[0-9]{4})\/(?P<MON>[0-9]{2})\/(?P<DAY>[0-9]{2})[\- ]+(?P<HR>[0-9]+):(?P<MIN>[0-9]+):(?P<SEC>[0-9]+)'
-		m = re.search(rexx,tmp)
-		#print "year:", int(m.group('YEAR')), "month", int(m.group('MON')), "day", int(m.group('DAY')), "hour", int(m.group('HR')), "minute", int(m.group('MIN')), "second", int(m.group('SEC'))
-		result = datetime.datetime(int(m.group('YEAR')), int(m.group('MON')), int(m.group('DAY')), int(m.group('HR')), int(m.group('MIN')), int(m.group('SEC')))
-	else:
-		raise FpdbError("invalid site in parseHandStartTime")
-	
-	if (site=="ftp" or site=="ps") and not isUTC: #these use US ET
-		result+=datetime.timedelta(hours=5)
-	
-	return result
-#end def parseHandStartTime
-
-#parses the names out of the given lines and returns them as an array
-def parseNames(lines):
-	result = []
-	for i in range (len(lines)):
-		pos1=lines[i].find(":")+2
-		pos2=lines[i].rfind("(")-1
-		tmp=lines[i][pos1:pos2]
-		#print "parseNames, tmp original:",tmp
-		tmp=unicode(tmp,"latin-1")
-		#print "parseNames, tmp after unicode latin-1 conversion:",tmp
-		result.append(tmp)
-	return result
-#end def parseNames
-
-#returns an array with the positions of the respective players
-def parsePositions (hand, names):
-	#prep array
-	positions=[]
-	for i in range(len(names)):
-		positions.append(-1)
-	
-	#find blinds
-	sb,bb=-1,-1
-	for i in range (len(hand)):
-		if (sb==-1 and hand[i].find("small blind")!=-1 and hand[i].find("dead small blind")==-1):
-			sb=hand[i]
-			#print "sb:",sb
-		if (bb==-1 and hand[i].find("big blind")!=-1 and hand[i].find("dead big blind")==-1):
-			bb=hand[i]
-			#print "bb:",bb
-
-	#identify blinds
-	#print "parsePositions before recognising sb/bb. names:",names
-	sbExists=True
-	if (sb!=-1):
-		sb=recognisePlayerNo(sb, names, "bet")
-	else:
-		sbExists=False
-	if (bb!=-1):
-		bb=recognisePlayerNo(bb, names, "bet")
-		
-#	print "sb = ", sb, "bb = ", bb
-	if bb == sb:
-		sbExists = False
-		sb = -1
-	
-	#write blinds into array
-	if (sbExists):
-		positions[sb]="S"
-	positions[bb]="B"
-	
-	
-	#fill up rest of array
-	if (sbExists):
-		arraypos=sb-1
-	else:
-		arraypos=bb-1
-	distFromBtn=0
-	while (arraypos>=0 and arraypos != bb):
-		#print "parsePositions first while, arraypos:",arraypos,"positions:",positions
-		positions[arraypos]=distFromBtn
-		arraypos-=1
-		distFromBtn+=1
-
-	# eric - this takes into account dead seats between blinds
-	if sbExists:
-		i = bb - 1
-		while positions[i] < 0 and i != sb:
-			positions[i] = 9
-			i -= 1
-	### RHH - Changed to set the null seats before BB to "9"			
-	if sbExists:
-		i = sb-1
-	else:
-		i = bb-1
-	while positions[i] < 0:
-		positions[i]=9
-		i-=1
-	
-	arraypos=len(names)-1
-	if (bb!=0 or (bb==0 and sbExists==False) or (bb == 1 and sb != arraypos) ):
-		while (arraypos>bb and arraypos > sb):
-			positions[arraypos]=distFromBtn
-			arraypos-=1
-			distFromBtn+=1
-			
-	for i in range (len(names)):
-		if positions[i]==-1:
-			print "parsePositions names:",names
-			print "result:",positions
-			raise FpdbError ("failed to read positions")
-#	print str(positions), "\n"
-	return positions
-#end def parsePositions
-
-#simply parses the rake amount and returns it as an int
-def parseRake(line):
-	pos=line.find("Rake")+6
-	rake=float2int(line[pos:])
-	return rake
-#end def parseRake
-
-def parseSiteHandNo(topline):
-	"""returns the hand no assigned by the poker site"""
-	pos1=topline.find("#")+1
-	pos2=topline.find(":")
-	return topline[pos1:pos2]
-#end def parseSiteHandNo
-
-def parseTableLine(site, base, line):
-	"""returns a dictionary with maxSeats and tableName"""
-	if site=="ps":
-		pos1=line.find('\'')+1
-		pos2=line.find('\'', pos1)
-		#print "table:",line[pos1:pos2]
-		pos3=pos2+2
-		pos4=line.find("-max")
-		#print "seats:",line[pos3:pos4]
-		return {'maxSeats':int(line[pos3:pos4]), 'tableName':line[pos1:pos2]}
-	elif site=="ftp":
-		pos1=line.find("Table ")+6
-		pos2=line.find("-")-1
-		if base=="hold":
-			maxSeats=9
-		elif base=="stud":
-			maxSeats=8
-			
-		if line.find("6 max")!=-1:
-			maxSeats=6
-		elif line.find("4 max")!=-1:
-			maxSeats=4
-		elif line.find("heads up")!=-1:
-			maxSeats=2
-			
-		return {'maxSeats':maxSeats, 'tableName':line[pos1:pos2]}
-	else:
-		raise FpdbError("invalid site ID")
-#end def parseTableLine
-
-#returns the hand no assigned by the poker site
-def parseTourneyNo(topline):
-	pos1=topline.find("Tournament #")+12
-	pos2=topline.find(",", pos1)
-	#print "parseTourneyNo pos1:",pos1,"  pos2:",pos2, "  result:",topline[pos1:pos2]
-	return topline[pos1:pos2]
-#end def parseTourneyNo
-
-#parses a win/collect line. manipulates the passed array winnings, no explicit return
-def parseWinLine(line, site, names, winnings, isTourney):
-	#print "parseWinLine: line:",line
-	for i in range(len(names)):
-		if (line.startswith(names[i].encode("latin-1"))): #found a winner
-			if isTourney:
-				pos1=line.rfind("collected ")+10
-				if (site=="ftp"):
-					pos2=line.find(")", pos1)
-				elif (site=="ps"):
-					pos2=line.find(" ", pos1)
-				winnings[i]+=int(line[pos1:pos2])
-			else:
-				pos1=line.rfind("$")+1
-				if (site=="ftp"):
-					pos2=line.find(")", pos1)
-				elif (site=="ps"):
-					pos2=line.find(" ", pos1)
-				winnings[i]+=float2int(line[pos1:pos2])
-#end def parseWinLine
-
-#returns the category (as per database) string for the given line
-def recogniseCategory(line):
-	if (line.find("Razz")!=-1):
-		return "razz"
-	elif (line.find("Hold'em")!=-1):
-		return "holdem"
-	elif (line.find("Omaha")!=-1 and line.find("Hi/Lo")==-1 and line.find("H/L")==-1):
-		return "omahahi"
-	elif (line.find("Omaha")!=-1 and (line.find("Hi/Lo")!=-1 or line.find("H/L")!=-1)):
-		return "omahahilo"
-	elif (line.find("Stud")!=-1 and line.find("Hi/Lo")==-1 and line.find("H/L")==-1):
-		return "studhi"
-	elif (line.find("Stud")!=-1 and (line.find("Hi/Lo")!=-1 or line.find("H/L")!=-1)):
-		return "studhilo"
-	else:
-		raise FpdbError("failed to recognise category, line:"+line)
-#end def recogniseCategory
-
-#returns the int for the gametype_id for the given line
-def recogniseGametypeID(cursor, topline, smallBlindLine, site_id, category, isTourney):#todo: this method is messy
-	#if (topline.find("HORSE")!=-1):
-	#	raise FpdbError("recogniseGametypeID: HORSE is not yet supported.")
-	
-	#note: the below variable names small_bet and big_bet are misleading, in NL/PL they mean small/big blind
-	if isTourney:
-		type="tour"
-		pos1=topline.find("(")+1
-		if (topline[pos1]=="H" or topline[pos1]=="O" or topline[pos1]=="R" or topline[pos1]=="S" or topline[pos1+2]=="C"):
-			pos1=topline.find("(", pos1)+1
-		pos2=topline.find("/", pos1)
-		small_bet=int(topline[pos1:pos2])
-	else:
-		type="ring"
-		pos1=topline.find("$")+1
-		pos2=topline.find("/$")
-		small_bet=float2int(topline[pos1:pos2])
-	
-	pos1=pos2+2
-	if isTourney:
-		pos1-=1	
-	if (site_id==1): #ftp
-		pos2=topline.find(" ", pos1)
-	elif (site_id==2): #ps
-		pos2=topline.find(")")
-	
-	if pos2<=pos1:
-		pos2=topline.find(")", pos1)
-	
-	if isTourney:
-		big_bet=int(topline[pos1:pos2])
-	else:
-		big_bet=float2int(topline[pos1:pos2])
-	
-	if (topline.find("No Limit")!=-1):
-		limit_type="nl"
-		if (topline.find("Cap No")!=-1):
-			limit_type="cn"
-	elif (topline.find("Pot Limit")!=-1):
-		limit_type="pl"
-		if (topline.find("Cap Pot")!=-1):
-			limit_type="cp"
-	else:
-		limit_type="fl"
-	
-	#print "recogniseGametypeID small_bet/blind:",small_bet,"big bet/blind:", big_bet,"limit type:",limit_type
-	if (limit_type=="fl"):
-		cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBet=%s AND bigBet=%s", (site_id, type, category, limit_type, small_bet, big_bet))
-	else:
-		cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBlind=%s AND bigBlind=%s", (site_id, type, category, limit_type, small_bet, big_bet))
-	result=cursor.fetchone()
-	#print "tried SELECTing gametypes.id, result:",result
-	
-	try:
-		len(result)
-	except TypeError:
-		if category=="holdem" or category=="omahahi" or category=="omahahilo":
-			base="hold"
-		else:
-			base="stud"
-		
-		if category=="holdem" or category=="omahahi" or category=="studhi":
-			hiLo='h'
-		elif category=="razz":
-			hiLo='l'
-		else:
-			hiLo='s'
-		
-		if (limit_type=="fl"):
-			big_blind=small_bet
-			if base=="hold":
-				if smallBlindLine==topline:
-					raise FpdbError("invalid small blind line")
-				elif isTourney:
-					pos=smallBlindLine.rfind(" ")+1
-					small_blind=int(smallBlindLine[pos:])
-				else:
-					pos=smallBlindLine.rfind("$")+1
-					small_blind=float2int(smallBlindLine[pos:])
-			else:
-				small_blind=0
-			cursor.execute("""INSERT INTO Gametypes
-			(siteId, type, base, category, limitType, hiLo, smallBlind, bigBlind, smallBet, bigBet)
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""", (site_id, type, base, category, limit_type, hiLo, small_blind, big_blind, small_bet, big_bet))
-			cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBet=%s AND bigBet=%s", (site_id, type, category, limit_type, small_bet, big_bet))
-		else:
-			cursor.execute("""INSERT INTO Gametypes
-			(siteId, type, base, category, limitType, hiLo, smallBlind, bigBlind, smallBet, bigBet)
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""", (site_id, type, base, category, limit_type, hiLo, small_bet, big_bet, 0, 0))#remember, for these bet means blind
-			cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBlind=%s AND bigBlind=%s", (site_id, type, category, limit_type, small_bet, big_bet))
-
-		result=cursor.fetchone()
-		#print "created new gametypes.id:",result
-	
-	return result[0]
-#end def recogniseGametypeID
-
-def recogniseTourneyTypeId(cursor, siteId, buyin, fee, knockout, rebuyOrAddon):
-	cursor.execute ("SELECT id FROM TourneyTypes WHERE siteId=%s AND buyin=%s AND fee=%s AND knockout=%s AND rebuyOrAddon=%s", (siteId, buyin, fee, knockout, rebuyOrAddon))
-	result=cursor.fetchone()
-	#print "tried SELECTing gametypes.id, result:",result
-	
-	try:
-		len(result)
-	except TypeError:#this means we need to create a new entry
-		cursor.execute("""INSERT INTO TourneyTypes (siteId, buyin, fee, knockout, rebuyOrAddon) VALUES (%s, %s, %s, %s, %s)""", (siteId, buyin, fee, knockout, rebuyOrAddon))
-		cursor.execute("SELECT id FROM TourneyTypes WHERE siteId=%s AND buyin=%s AND fee=%s AND knockout=%s AND rebuyOrAddon=%s", (siteId, buyin, fee, knockout, rebuyOrAddon))
-		result=cursor.fetchone()
-	return result[0]
-#end def recogniseTourneyTypeId
-
-#returns the SQL ids of the names given in an array
-def recognisePlayerIDs(cursor, names, site_id):
-	result = []
-	for i in range (len(names)):
-		cursor.execute ("SELECT id FROM Players WHERE name=%s", (names[i],))
-		tmp=cursor.fetchall()
-		if (len(tmp)==0): #new player
-			cursor.execute ("INSERT INTO Players (name, siteId) VALUES (%s, %s)", (names[i], site_id))
-			#print "Number of players rows inserted: %d" % cursor.rowcount
-			cursor.execute ("SELECT id FROM Players WHERE name=%s", (names[i],))
-			tmp=cursor.fetchall()
-		#print "recognisePlayerIDs, names[i]:",names[i],"tmp:",tmp
-		result.append(tmp[0][0])
-	return result
-#end def recognisePlayerIDs
-
-#recognises the name in the given line and returns its array position in the given array
-def recognisePlayerNo(line, names, atype):
-	#print "recogniseplayerno, names:",names
-	for i in range (len(names)):
-		if (atype=="unbet"):
-			if (line.endswith(names[i].encode("latin-1"))):
-				return (i)
-		elif (line.startswith("Dealt to ")):
-			#print "recognisePlayerNo, card precut, line:",line
-			tmp=line[9:]
-			#print "recognisePlayerNo, card postcut, tmp:",tmp
-			if (tmp.startswith(names[i].encode("latin-1"))):
-				return (i)
-		elif (line.startswith("Seat ")):
-			if (line.startswith("Seat 10")):
-				tmp=line[9:]
-			else:
-				tmp=line[8:]
-			
-			if (tmp.startswith(names[i].encode("latin-1"))):
-				return (i)
-		else:
-			if (line.startswith(names[i].encode("latin-1"))):
-				return (i)
-	#if we're here we mustve failed
-	raise FpdbError ("failed to recognise player in: "+line+" atype:"+atype)
-#end def recognisePlayerNo
-
-#returns the site abbreviation for the given site
-def recogniseSite(line):
-	if (line.startswith("Full Tilt Poker")):
-		return "ftp"
-	elif (line.startswith("PokerStars")):
-		return "ps"
-	else:
-		raise FpdbError("failed to recognise site, line:"+line)
-#end def recogniseSite
-
-#returns the ID of the given site
-def recogniseSiteID(cursor, site):
-	if (site=="ftp"):
-		return 1
-		#cursor.execute("SELECT id FROM Sites WHERE name = ('Full Tilt Poker')")
-	elif (site=="ps"):
-		return 2
-		#cursor.execute("SELECT id FROM Sites WHERE name = ('PokerStars')")
-	else:
-		raise FpdbError("invalid site in recogniseSiteID: "+site)
-	return cursor.fetchall()[0][0]
-#end def recogniseSiteID
-
-#removes trailing \n from the given array
-def removeTrailingEOL(arr):
-	for i in range(len(arr)):
-		if (arr[i].endswith("\n")):
-			#print "arr[i] before removetrailingEOL:", arr[i]
-			arr[i]=arr[i][:-1]
-			#print "arr[i] after removetrailingEOL:", arr[i]
-	return arr
-#end def removeTrailingEOL
-
-#splits the rake according to the proportion of pot won. manipulates the second passed array.
-def splitRake(winnings, rakes, totalRake):
-	winnercnt=0
-	totalWin=0
-	for i in range(len(winnings)):
-		if winnings[i]!=0:
-			winnercnt+=1
-			totalWin+=winnings[i]
-			firstWinner=i
-	if winnercnt==1:
-		rakes[firstWinner]=totalRake
-	else:
-		totalWin=float(totalWin)
-		for i in range(len(winnings)):
-			if winnings[i]!=0:
-				winPortion=winnings[i]/totalWin
-				rakes[i]=totalRake*winPortion
-#end def splitRake
-
-def storeActions(cursor, handsPlayersIds, actionTypes, allIns, actionAmounts, actionNos):
-#stores into table hands_actions
-	#print "start of storeActions, actionNos:",actionNos
-	#print "                  action_amounts:",action_amounts
-	for i in range (len(actionTypes)): #iterate through streets
-		for j in range (len(actionTypes[i])): #iterate through names
-			for k in range (len(actionTypes[i][j])):  #iterate through individual actions of that player on that street
-				cursor.execute ("INSERT INTO HandsActions (handPlayerId, street, actionNo, action, allIn, amount) VALUES (%s, %s, %s, %s, %s, %s)", (handsPlayersIds[j], i, actionNos[i][j][k], actionTypes[i][j][k], allIns[i][j][k], actionAmounts[i][j][k]))
-#end def storeActions
-
-def store_board_cards(cursor, hands_id, board_values, board_suits):
-#stores into table board_cards
-	cursor.execute ("""INSERT INTO BoardCards (handId, card1Value, card1Suit,
-	card2Value, card2Suit, card3Value, card3Suit, card4Value, card4Suit,
-	card5Value, card5Suit) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
-	(hands_id, board_values[0], board_suits[0], board_values[1], board_suits[1],
-	board_values[2], board_suits[2], board_values[3], board_suits[3],
-	board_values[4], board_suits[4]))
-#end def store_board_cards
-
-def storeHands(cursor, site_hand_no, gametype_id, hand_start_time, names, tableName, maxSeats):
-#stores into table hands
-	cursor.execute ("INSERT INTO Hands (siteHandNo, gametypeId, handStart, seats, tableName, importTime, maxSeats) VALUES (%s, %s, %s, %s, %s, %s, %s)", (site_hand_no, gametype_id, hand_start_time, len(names), tableName, datetime.datetime.today(), maxSeats))
-	#todo: find a better way of doing this...
-	cursor.execute("SELECT id FROM Hands WHERE siteHandNo=%s AND gametypeId=%s", (site_hand_no, gametype_id))
-	return cursor.fetchall()[0][0]
-#end def storeHands
-
-def store_hands_players_holdem_omaha(cursor, category, hands_id, player_ids, start_cashes, positions, card_values, card_suits, winnings, rakes, seatNos):
-	result=[]
-	if (category=="holdem"):
-		for i in range (len(player_ids)):
-			cursor.execute ("""
-			INSERT INTO HandsPlayers 
-			(handId, playerId, startCash, position,
-			card1Value, card1Suit, card2Value, card2Suit, winnings, rake, seatNo) 
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
-			(hands_id, player_ids[i], start_cashes[i], positions[i],
-			card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-			winnings[i], rakes[i], seatNos[i]))
-			cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
-			result.append(cursor.fetchall()[0][0])
-	elif (category=="omahahi" or category=="omahahilo"):
-		for i in range (len(player_ids)):
-			cursor.execute ("""INSERT INTO HandsPlayers 
-			(handId, playerId, startCash,	position,
-			card1Value, card1Suit, card2Value, card2Suit,
-			card3Value, card3Suit, card4Value, card4Suit, winnings, rake, seatNo) 
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
-			(hands_id, player_ids[i], start_cashes[i], positions[i],
-			card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-			card_values[i][2], card_suits[i][2], card_values[i][3],	card_suits[i][3],
-			winnings[i], rakes[i], seatNos[i]))
-			cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
-			result.append(cursor.fetchall()[0][0])
-	else:
-		raise FpdbError("invalid category")
-	return result
-#end def store_hands_players_holdem_omaha
-
-def store_hands_players_stud(cursor, hands_id, player_ids, start_cashes, antes,
-			card_values, card_suits, winnings, rakes, seatNos):
-#stores hands_players rows for stud/razz games. returns an array of the resulting IDs
-	result=[]
-	#print "before inserts in store_hands_players_stud, antes:", antes
-	for i in range (len(player_ids)):
-		cursor.execute ("""INSERT INTO HandsPlayers 
-		(handId, playerId, startCash, ante,
-		card1Value, card1Suit, card2Value, card2Suit,
-		card3Value, card3Suit, card4Value, card4Suit,
-		card5Value, card5Suit, card6Value, card6Suit,
-		card7Value, card7Suit, winnings, rake, seatNo) 
-		VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
-		%s, %s, %s, %s)""",
-		(hands_id, player_ids[i], start_cashes[i], antes[i],
-		card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-		card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
-		card_values[i][4], card_suits[i][4], card_values[i][5], card_suits[i][5],
-		card_values[i][6], card_suits[i][6], winnings[i], rakes[i], seatNos[i]))
-		cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
-		result.append(cursor.fetchall()[0][0])
-	return result
-#end def store_hands_players_stud
-
-def store_hands_players_holdem_omaha_tourney(cursor, category, hands_id, player_ids, start_cashes, positions, card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids):
-#stores hands_players for tourney holdem/omaha hands
-	result=[]
-	for i in range (len(player_ids)):
-		if len(card_values[0])==2:
-			cursor.execute ("""INSERT INTO HandsPlayers 
-			(handId, playerId, startCash, position,
-			card1Value, card1Suit, card2Value, card2Suit,
-			winnings, rake, tourneysPlayersId, seatNo) 
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
-			(hands_id, player_ids[i], start_cashes[i], positions[i],
-			card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-			winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
-		elif len(card_values[0])==4:
-			cursor.execute ("""INSERT INTO HandsPlayers 
-			(handId, playerId, startCash, position,
-			card1Value, card1Suit, card2Value, card2Suit,
-			card3Value, card3Suit, card4Value, card4Suit,
-			winnings, rake, tourneysPlayersId, seatNo) 
-			VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
-			(hands_id, player_ids[i], start_cashes[i], positions[i],
-			card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-			card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
-			winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
-		else:
-			raise FpdbError ("invalid card_values length:"+str(len(card_values[0])))
-		cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
-		result.append(cursor.fetchall()[0][0])
-	
-	return result
-#end def store_hands_players_holdem_omaha_tourney
-
-def store_hands_players_stud_tourney(cursor, hands_id, player_ids, start_cashes,
-			antes, card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids):
-#stores hands_players for tourney stud/razz hands
-	result=[]
-	for i in range (len(player_ids)):
-		cursor.execute ("""INSERT INTO HandsPlayers 
-		(handId, playerId, startCash,	ante,
-		card1Value, card1Suit, card2Value, card2Suit,
-		card3Value, card3Suit, card4Value, card4Suit,
-		card5Value, card5Suit, card6Value, card6Suit,
-		card7Value, card7Suit, winnings, rake, tourneysPlayersId, seatNo) 
-		VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
-		%s, %s, %s, %s, %s, %s)""",
-		(hands_id, player_ids[i], start_cashes[i], antes[i],
-		card_values[i][0], card_suits[i][0], card_values[i][1],	card_suits[i][1],
-		card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
-		card_values[i][4], card_suits[i][4], card_values[i][5], card_suits[i][5],
-		card_values[i][6], card_suits[i][6], winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
-		cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
-		result.append(cursor.fetchall()[0][0])
-	return result
-#end def store_hands_players_stud_tourney
-
-def generateHudCacheData(player_ids, base, category, action_types, allIns, actionTypeByNo, winnings, totalWinnings, positions):
-	"""calculates data for the HUD during import. IMPORTANT: if you change this method make sure to also change the following storage method and table_viewer.prepare_data if necessary"""
-	#setup subarrays of the result dictionary.
-	street0VPI=[]
-	street0Aggr=[]
-	street0_3B4BChance=[]
-	street0_3B4BDone=[]
-	street1Seen=[]
-	street2Seen=[]
-	street3Seen=[]
-	street4Seen=[]
-	sawShowdown=[]
-	street1Aggr=[]
-	street2Aggr=[]
-	street3Aggr=[]
-	street4Aggr=[]
-	otherRaisedStreet1=[]
-	otherRaisedStreet2=[]
-	otherRaisedStreet3=[]
-	otherRaisedStreet4=[]
-	foldToOtherRaisedStreet1=[]
-	foldToOtherRaisedStreet2=[]
-	foldToOtherRaisedStreet3=[]
-	foldToOtherRaisedStreet4=[]
-	wonWhenSeenStreet1=[]
-	
-	wonAtSD=[]
-	stealAttemptChance=[]
-	stealAttempted=[]
-	hudDataPositions=[]
-	
-	firstPfRaiseByNo=-1
-	firstPfRaiserId=-1
-	firstPfRaiserNo=-1
-	firstPfCallByNo=-1
-	firstPfCallerId=-1
-	for i in range(len(actionTypeByNo[0])):
-		if actionTypeByNo[0][i][1]=="bet":
-			firstPfRaiseByNo=i
-			firstPfRaiserId=actionTypeByNo[0][i][0]
-			for j in range(len(player_ids)):
-				if player_ids[j]==firstPfRaiserId:
-					firstPfRaiserNo=j
-					break
-			break
-	for i in range(len(actionTypeByNo[0])):
-		if actionTypeByNo[0][i][1]=="call":
-			firstPfCallByNo=i
-			firstPfCallerId=actionTypeByNo[0][i][0]
-			break
-	
-	cutoffId=-1
-	buttonId=-1
-	sbId=-1
-	bbId=-1
-	if base=="hold":
-		for player in range(len(positions)):
-			if positions==1:
-				cutoffId=player_ids[player]
-			if positions==0:
-				buttonId=player_ids[player]
-			if positions=='S':
-				sbId=player_ids[player]
-			if positions=='B':
-				bbId=player_ids[player]
-			
-	someoneStole=False
-	
-	#run a loop for each player preparing the actual values that will be commited to SQL
-	for player in range (len(player_ids)):
-		#set default values
-		myStreet0VPI=False
-		myStreet0Aggr=False
-		myStreet0_3B4BChance=False
-		myStreet0_3B4BDone=False
-		myStreet1Seen=False
-		myStreet2Seen=False
-		myStreet3Seen=False
-		myStreet4Seen=False
-		mySawShowdown=False
-		myStreet1Aggr=False
-		myStreet2Aggr=False
-		myStreet3Aggr=False
-		myStreet4Aggr=False
-		myOtherRaisedStreet1=False
-		myOtherRaisedStreet2=False
-		myOtherRaisedStreet3=False
-		myOtherRaisedStreet4=False
-		myFoldToOtherRaisedStreet1=False
-		myFoldToOtherRaisedStreet2=False
-		myFoldToOtherRaisedStreet3=False
-		myFoldToOtherRaisedStreet4=False
-		myWonWhenSeenStreet1=0.0
-		myWonAtSD=0.0
-		myStealAttemptChance=False
-		myStealAttempted=False
-		
-		#calculate VPIP and PFR
-		street=0
-		heroPfRaiseCount=0
-		for count in range (len(action_types[street][player])):#finally individual actions
-			currentAction=action_types[street][player][count]
-			if currentAction=="bet":
-				myStreet0Aggr=True
-			if (currentAction=="bet" or currentAction=="call"):
-				myStreet0VPI=True
-		
-		#PF3B4BChance and PF3B4B
-		pfFold=-1
-		pfRaise=-1
-		if firstPfRaiseByNo!=-1:
-			for i in range(len(actionTypeByNo[0])):
-				if actionTypeByNo[0][i][0]==player_ids[player]:
-					if actionTypeByNo[0][i][1]=="bet" and pfRaise==-1 and i>firstPfRaiseByNo:
-						pfRaise=i
-					if actionTypeByNo[0][i][1]=="fold" and pfFold==-1:
-						pfFold=i
-			if pfFold==-1 or pfFold>firstPfRaiseByNo:
-				myStreet0_3B4BChance=True
-				if pfRaise>firstPfRaiseByNo:
-					myStreet0_3B4BDone=True
-		
-		#steal calculations
-		if base=="hold":
-			if len(player_ids)>=5: #no point otherwise
-				if positions[player]==1:
-					if firstPfRaiserId==player_ids[player]:
-						myStealAttemptChance=True
-						myStealAttempted=True
-					elif firstPfRaiserId==buttonId or firstPfRaiserId==sbId or firstPfRaiserId==bbId or firstPfRaiserId==-1:
-						myStealAttemptChance=True
-				if positions[player]==0:
-					if firstPfRaiserId==player_ids[player]:
-						myStealAttemptChance=True
-						myStealAttempted=True
-					elif firstPfRaiserId==sbId or firstPfRaiserId==bbId or firstPfRaiserId==-1:
-						myStealAttemptChance=True
-				if positions[player]=='S':
-					if firstPfRaiserId==player_ids[player]:
-						myStealAttemptChance=True
-						myStealAttempted=True
-					elif firstPfRaiserId==bbId or firstPfRaiserId==-1:
-						myStealAttemptChance=True
-				if positions[player]=='B':
-					pass
-			
-				if myStealAttempted:
-					someoneStole=True
-		
-		
-		#calculate saw* values
-		isAllIn=False
-		for i in range(len(allIns[0][player])):
-			if allIns[0][player][i]:
-				isAllIn=True
-		if (len(action_types[1][player])>0 or isAllIn):
-			myStreet1Seen=True
-
-			for i in range(len(allIns[1][player])):
-				if allIns[1][player][i]:
-					isAllIn=True
-			if (len(action_types[2][player])>0 or isAllIn):
-				myStreet2Seen=True
-
-				for i in range(len(allIns[2][player])):
-					if allIns[2][player][i]:
-						isAllIn=True
-				if (len(action_types[3][player])>0 or isAllIn):
-					myStreet3Seen=True
-
-					#print "base:", base
-					if base=="hold":
-						mySawShowdown=True
-						for count in range (len(action_types[3][player])):
-							if action_types[3][player][count]=="fold":
-								mySawShowdown=False
-					else:
-						#print "in else"
-						for i in range(len(allIns[3][player])):
-							if allIns[3][player][i]:
-								isAllIn=True
-						if (len(action_types[4][player])>0 or isAllIn):
-							#print "in if"
-							myStreet4Seen=True
-
-							mySawShowdown=True
-							for count in range (len(action_types[4][player])):
-								if action_types[4][player][count]=="fold":
-									mySawShowdown=False
-						
-
-		#flop stuff
-		street=1
-		if myStreet1Seen:
-			for count in range(len(action_types[street][player])):
-				if action_types[street][player][count]=="bet":
-					myStreet1Aggr=True
-			
-			for otherPlayer in range (len(player_ids)):
-				if player==otherPlayer:
-					pass
-				else:
-					for countOther in range (len(action_types[street][otherPlayer])):
-						if action_types[street][otherPlayer][countOther]=="bet":
-							myOtherRaisedStreet1=True
-							for countOtherFold in range (len(action_types[street][player])):
-								if action_types[street][player][countOtherFold]=="fold":
-									myFoldToOtherRaisedStreet1=True
-		
-		#turn stuff - copy of flop with different vars
-		street=2
-		if myStreet2Seen:
-			for count in range(len(action_types[street][player])):
-				if action_types[street][player][count]=="bet":
-					myStreet2Aggr=True
-			
-			for otherPlayer in range (len(player_ids)):
-				if player==otherPlayer:
-					pass
-				else:
-					for countOther in range (len(action_types[street][otherPlayer])):
-						if action_types[street][otherPlayer][countOther]=="bet":
-							myOtherRaisedStreet2=True
-							for countOtherFold in range (len(action_types[street][player])):
-								if action_types[street][player][countOtherFold]=="fold":
-									myFoldToOtherRaisedStreet2=True
-		
-		#river stuff - copy of flop with different vars
-		street=3
-		if myStreet3Seen:
-			for count in range(len(action_types[street][player])):
-				if action_types[street][player][count]=="bet":
-					myStreet3Aggr=True
-			
-			for otherPlayer in range (len(player_ids)):
-				if player==otherPlayer:
-					pass
-				else:
-					for countOther in range (len(action_types[street][otherPlayer])):
-						if action_types[street][otherPlayer][countOther]=="bet":
-							myOtherRaisedStreet3=True
-							for countOtherFold in range (len(action_types[street][player])):
-								if action_types[street][player][countOtherFold]=="fold":
-									myFoldToOtherRaisedStreet3=True
-		
-		#stud river stuff - copy of flop with different vars
-		street=4
-		if myStreet4Seen:
-			for count in range(len(action_types[street][player])):
-				if action_types[street][player][count]=="bet":
-					myStreet4Aggr=True
-			
-			for otherPlayer in range (len(player_ids)):
-				if player==otherPlayer:
-					pass
-				else:
-					for countOther in range (len(action_types[street][otherPlayer])):
-						if action_types[street][otherPlayer][countOther]=="bet":
-							myOtherRaisedStreet4=True
-							for countOtherFold in range (len(action_types[street][player])):
-								if action_types[street][player][countOtherFold]=="fold":
-									myFoldToOtherRaisedStreet4=True
-		
-		if winnings[player]!=0:
-			if myStreet1Seen:
-				myWonWhenSeenStreet1=winnings[player]/float(totalWinnings)
-				if mySawShowdown:
-					myWonAtSD=myWonWhenSeenStreet1
-		
-		#add each value to the appropriate array
-		street0VPI.append(myStreet0VPI)
-		street0Aggr.append(myStreet0Aggr)
-		street0_3B4BChance.append(myStreet0_3B4BChance)
-		street0_3B4BDone.append(myStreet0_3B4BDone)
-		street1Seen.append(myStreet1Seen)
-		street2Seen.append(myStreet2Seen)
-		street3Seen.append(myStreet3Seen)
-		street4Seen.append(myStreet4Seen)
-		sawShowdown.append(mySawShowdown)
-		street1Aggr.append(myStreet1Aggr)
-		street2Aggr.append(myStreet2Aggr)
-		street3Aggr.append(myStreet3Aggr)
-		street4Aggr.append(myStreet4Aggr)
-		otherRaisedStreet1.append(myOtherRaisedStreet1)
-		otherRaisedStreet2.append(myOtherRaisedStreet2)
-		otherRaisedStreet3.append(myOtherRaisedStreet3)
-		otherRaisedStreet4.append(myOtherRaisedStreet4)
-		foldToOtherRaisedStreet1.append(myFoldToOtherRaisedStreet1)
-		foldToOtherRaisedStreet2.append(myFoldToOtherRaisedStreet2)
-		foldToOtherRaisedStreet3.append(myFoldToOtherRaisedStreet3)
-		foldToOtherRaisedStreet4.append(myFoldToOtherRaisedStreet4)
-		wonWhenSeenStreet1.append(myWonWhenSeenStreet1)
-		wonAtSD.append(myWonAtSD)
-		stealAttemptChance.append(myStealAttemptChance)
-		stealAttempted.append(myStealAttempted)
-		if base=="hold":
-			pos=positions[player]
-			if pos=='B':
-				hudDataPositions.append('B')
-			elif pos=='S':
-				hudDataPositions.append('S')
-			elif pos==0:
-				hudDataPositions.append('D')
-			elif pos==1:
-				hudDataPositions.append('C')
-			elif pos>=2 and pos<=4:
-				hudDataPositions.append('M')
-			elif pos>=5 and pos<=8:
-				hudDataPositions.append('E')
-			### RHH Added this elif to handle being a dead hand before the BB (pos==9)
-			elif pos==9:
-				hudDataPositions.append('X')
-			else:
-				raise FpdbError("invalid position")
-		elif base=="stud":
-			#todo: stud positions and steals
-			pass
-	
-	#add each array to the to-be-returned dictionary
-	result={'street0VPI':street0VPI}
-	result['street0Aggr']=street0Aggr
-	result['street0_3B4BChance']=street0_3B4BChance
-	result['street0_3B4BDone']=street0_3B4BDone
-	result['street1Seen']=street1Seen
-	result['street2Seen']=street2Seen
-	result['street3Seen']=street3Seen
-	result['street4Seen']=street4Seen
-	result['sawShowdown']=sawShowdown
-	
-	result['street1Aggr']=street1Aggr
-	result['otherRaisedStreet1']=otherRaisedStreet1
-	result['foldToOtherRaisedStreet1']=foldToOtherRaisedStreet1
-	result['street2Aggr']=street2Aggr
-	result['otherRaisedStreet2']=otherRaisedStreet2
-	result['foldToOtherRaisedStreet2']=foldToOtherRaisedStreet2
-	result['street3Aggr']=street3Aggr
-	result['otherRaisedStreet3']=otherRaisedStreet3
-	result['foldToOtherRaisedStreet3']=foldToOtherRaisedStreet3
-	result['street4Aggr']=street4Aggr
-	result['otherRaisedStreet4']=otherRaisedStreet4
-	result['foldToOtherRaisedStreet4']=foldToOtherRaisedStreet4
-	result['wonWhenSeenStreet1']=wonWhenSeenStreet1
-	result['wonAtSD']=wonAtSD
-	result['stealAttemptChance']=stealAttemptChance
-	result['stealAttempted']=stealAttempted
-	
-	#now the various steal values
-	foldBbToStealChance=[]
-	foldedBbToSteal=[]
-	foldSbToStealChance=[]
-	foldedSbToSteal=[]
-	for player in range (len(player_ids)):
-		myFoldBbToStealChance=False
-		myFoldedBbToSteal=False
-		myFoldSbToStealChance=False
-		myFoldedSbToSteal=False
-		
-		if base=="hold":
-			if someoneStole and (positions[player]=='B' or positions[player]=='S') and firstPfRaiserId!=player_ids[player]:
-				street=0
-				for count in range (len(action_types[street][player])):#individual actions
-					if positions[player]=='B':
-						myFoldBbToStealChance=True
-						if action_types[street][player][count]=="fold":
-							myFoldedBbToSteal=True
-					if positions[player]=='S':
-						myFoldSbToStealChance=True
-						if action_types[street][player][count]=="fold":
-							myFoldedSbToSteal=True
-				
-				
-		foldBbToStealChance.append(myFoldBbToStealChance)
-		foldedBbToSteal.append(myFoldedBbToSteal)
-		foldSbToStealChance.append(myFoldSbToStealChance)
-		foldedSbToSteal.append(myFoldedSbToSteal)
-	result['foldBbToStealChance']=foldBbToStealChance
-	result['foldedBbToSteal']=foldedBbToSteal
-	result['foldSbToStealChance']=foldSbToStealChance
-	result['foldedSbToSteal']=foldedSbToSteal
-	
-	#now CB
-	street1CBChance=[]
-	street1CBDone=[]
-	didStreet1CB=[]
-	for player in range (len(player_ids)):
-		myStreet1CBChance=False
-		myStreet1CBDone=False
-		
-		if street0VPI[player]:
-			myStreet1CBChance=True
-			if street1Aggr[player]:
-				myStreet1CBDone=True
-				didStreet1CB.append(player_ids[player])
-				
-		street1CBChance.append(myStreet1CBChance)
-		street1CBDone.append(myStreet1CBDone)
-	result['street1CBChance']=street1CBChance
-	result['street1CBDone']=street1CBDone
-	
-	#now 2B
-	street2CBChance=[]
-	street2CBDone=[]
-	didStreet2CB=[]
-	for player in range (len(player_ids)):
-		myStreet2CBChance=False
-		myStreet2CBDone=False
-		
-		if street1CBDone[player]:
-			myStreet2CBChance=True
-			if street2Aggr[player]:
-				myStreet2CBDone=True
-				didStreet2CB.append(player_ids[player])
-
-		street2CBChance.append(myStreet2CBChance)
-		street2CBDone.append(myStreet2CBDone)
-	result['street2CBChance']=street2CBChance
-	result['street2CBDone']=street2CBDone
-	
-	#now 3B
-	street3CBChance=[]
-	street3CBDone=[]
-	didStreet3CB=[]
-	for player in range (len(player_ids)):
-		myStreet3CBChance=False
-		myStreet3CBDone=False
-		
-		if street2CBDone[player]:
-			myStreet3CBChance=True
-			if street3Aggr[player]:
-				myStreet3CBDone=True
-				didStreet3CB.append(player_ids[player])
-
-		street3CBChance.append(myStreet3CBChance)
-		street3CBDone.append(myStreet3CBDone)
-	result['street3CBChance']=street3CBChance
-	result['street3CBDone']=street3CBDone
-	
-	#and 4B
-	street4CBChance=[]
-	street4CBDone=[]
-	didStreet4CB=[]
-	for player in range (len(player_ids)):
-		myStreet4CBChance=False
-		myStreet4CBDone=False
-		
-		if street3CBDone[player]:
-			myStreet4CBChance=True
-			if street4Aggr[player]:
-				myStreet4CBDone=True
-				didStreet4CB.append(player_ids[player])
-		
-		street4CBChance.append(myStreet4CBChance)
-		street4CBDone.append(myStreet4CBDone)
-	result['street4CBChance']=street4CBChance
-	result['street4CBDone']=street4CBDone
-
-
-	result['position']=hudDataPositions	
-	
-	foldToStreet1CBChance=[]
-	foldToStreet1CBDone=[]
-	foldToStreet2CBChance=[]
-	foldToStreet2CBDone=[]
-	foldToStreet3CBChance=[]
-	foldToStreet3CBDone=[]
-	foldToStreet4CBChance=[]
-	foldToStreet4CBDone=[]
-	
-	for player in range (len(player_ids)):
-		myFoldToStreet1CBChance=False
-		myFoldToStreet1CBDone=False
-		foldToStreet1CBChance.append(myFoldToStreet1CBChance)
-		foldToStreet1CBDone.append(myFoldToStreet1CBDone)
-
-		myFoldToStreet2CBChance=False
-		myFoldToStreet2CBDone=False
-		foldToStreet2CBChance.append(myFoldToStreet2CBChance)
-		foldToStreet2CBDone.append(myFoldToStreet2CBDone)
-		
-		myFoldToStreet3CBChance=False
-		myFoldToStreet3CBDone=False
-		foldToStreet3CBChance.append(myFoldToStreet3CBChance)
-		foldToStreet3CBDone.append(myFoldToStreet3CBDone)
-		
-		myFoldToStreet4CBChance=False
-		myFoldToStreet4CBDone=False
-		foldToStreet4CBChance.append(myFoldToStreet4CBChance)
-		foldToStreet4CBDone.append(myFoldToStreet4CBDone)
-	
-	if len(didStreet1CB)>=1:
-		generateFoldToCB(1, player_ids, didStreet1CB, street1CBDone, foldToStreet1CBChance, foldToStreet1CBDone, actionTypeByNo)
-		
-		if len(didStreet2CB)>=1:
-			generateFoldToCB(2, player_ids, didStreet2CB, street2CBDone, foldToStreet2CBChance, foldToStreet2CBDone, actionTypeByNo)
-
-			if len(didStreet3CB)>=1:
-				generateFoldToCB(3, player_ids, didStreet3CB, street3CBDone, foldToStreet3CBChance, foldToStreet3CBDone, actionTypeByNo)
-
-				if len(didStreet4CB)>=1:
-					generateFoldToCB(4, player_ids, didStreet4CB, street4CBDone, foldToStreet4CBChance, foldToStreet4CBDone, actionTypeByNo)
-			
-	result['foldToStreet1CBChance']=foldToStreet1CBChance
-	result['foldToStreet1CBDone']=foldToStreet1CBDone
-	result['foldToStreet2CBChance']=foldToStreet2CBChance
-	result['foldToStreet2CBDone']=foldToStreet2CBDone
-	result['foldToStreet3CBChance']=foldToStreet3CBChance
-	result['foldToStreet3CBDone']=foldToStreet3CBDone
-	result['foldToStreet4CBChance']=foldToStreet4CBChance
-	result['foldToStreet4CBDone']=foldToStreet4CBDone
-
-
-	totalProfit=[]
-	
-	street1CheckCallRaiseChance=[]
-	street1CheckCallRaiseDone=[]
-	street2CheckCallRaiseChance=[]
-	street2CheckCallRaiseDone=[]
-	street3CheckCallRaiseChance=[]
-	street3CheckCallRaiseDone=[]
-	street4CheckCallRaiseChance=[]
-	street4CheckCallRaiseDone=[]
-	for player in range (len(player_ids)):
-		myTotalProfit=0
-		
-		myStreet1CheckCallRaiseChance=False
-		myStreet1CheckCallRaiseDone=False
-		myStreet2CheckCallRaiseChance=False
-		myStreet2CheckCallRaiseDone=False
-		myStreet3CheckCallRaiseChance=False
-		myStreet3CheckCallRaiseDone=False
-		myStreet4CheckCallRaiseChance=False
-		myStreet4CheckCallRaiseDone=False
-		
-		totalProfit.append(myTotalProfit)
-		
-		street1CheckCallRaiseChance.append(myStreet1CheckCallRaiseChance)
-		street1CheckCallRaiseDone.append(myStreet1CheckCallRaiseDone)
-		street2CheckCallRaiseChance.append(myStreet2CheckCallRaiseChance)
-		street2CheckCallRaiseDone.append(myStreet2CheckCallRaiseDone)
-		street3CheckCallRaiseChance.append(myStreet3CheckCallRaiseChance)
-		street3CheckCallRaiseDone.append(myStreet3CheckCallRaiseDone)
-		street4CheckCallRaiseChance.append(myStreet4CheckCallRaiseChance)
-		street4CheckCallRaiseDone.append(myStreet4CheckCallRaiseDone)
-
-	result['totalProfit']=totalProfit
-
-	result['street1CheckCallRaiseChance']=street1CheckCallRaiseChance
-	result['street1CheckCallRaiseDone']=street1CheckCallRaiseDone
-	result['street2CheckCallRaiseChance']=street2CheckCallRaiseChance
-	result['street2CheckCallRaiseDone']=street2CheckCallRaiseDone
-	result['street3CheckCallRaiseChance']=street3CheckCallRaiseChance
-	result['street3CheckCallRaiseDone']=street3CheckCallRaiseDone
-	result['street4CheckCallRaiseChance']=street4CheckCallRaiseChance
-	result['street4CheckCallRaiseDone']=street4CheckCallRaiseDone
-	return result
-#end def generateHudCacheData
-
-def generateFoldToCB(street, playerIDs, didStreetCB, streetCBDone, foldToStreetCBChance, foldToStreetCBDone, actionTypeByNo):
-	"""fills the passed foldToStreetCB* arrays appropriately depending on the given street"""
-	#print "beginning of generateFoldToCB, street:", street, "len(actionTypeByNo):", len(actionTypeByNo)
-	#print "len(actionTypeByNo[street]):",len(actionTypeByNo[street])
-	firstCBReaction=0
-	for action in range(len(actionTypeByNo[street])):
-		if actionTypeByNo[street][action][1]=="bet":
-			for player in didStreetCB:
-				if player==actionTypeByNo[street][action][0] and firstCBReaction==0:
-					firstCBReaction=action+1
-					break
-	
-	for action in actionTypeByNo[street][firstCBReaction:]:
-		for player in range(len(playerIDs)):
-			if playerIDs[player]==action[0]:
-				foldToStreetCBChance[player]=True
-				if action[1]=="fold":
-					foldToStreetCBDone[player]=True
-#end def generateFoldToCB
-
-def storeHudCache(cursor, base, category, gametypeId, playerIds, hudImportData):
-#	if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
-		
-		for player in range (len(playerIds)):
-			if base=="hold":
-				cursor.execute("SELECT * FROM HudCache WHERE gametypeId=%s AND playerId=%s AND activeSeats=%s AND position=%s", (gametypeId, playerIds[player], len(playerIds), hudImportData['position'][player]))
-			else:
-				cursor.execute("SELECT * FROM HudCache WHERE gametypeId=%s AND playerId=%s AND activeSeats=%s", (gametypeId, playerIds[player], len(playerIds)))
-			row=cursor.fetchone()
-			#print "gametypeId:", gametypeId, "playerIds[player]",playerIds[player], "len(playerIds):",len(playerIds), "row:",row
-			
-			try: len(row)
-			except TypeError:
-				row=[]
-			
-			if (len(row)==0):
-				#print "new huddata row"
-				doInsert=True
-				row=[]
-				row.append(0)#blank for id
-				row.append(gametypeId)
-				row.append(playerIds[player])
-				row.append(len(playerIds))#seats
-				for i in range(len(hudImportData)+2):
-					row.append(0)
-				
-			else:
-				doInsert=False
-				newrow=[]
-				for i in range(len(row)):
-					newrow.append(row[i])
-				row=newrow
-			
-			if base=="hold":
-				row[4]=hudImportData['position'][player]
-			else:
-				row[4]=0
-			row[5]=1 #tourneysGametypeId
-			row[6]+=1 #HDs
-			if hudImportData['street0VPI'][player]: row[7]+=1
-			if hudImportData['street0Aggr'][player]: row[8]+=1
-			if hudImportData['street0_3B4BChance'][player]: row[9]+=1
-			if hudImportData['street0_3B4BDone'][player]: row[10]+=1
-			if hudImportData['street1Seen'][player]: row[11]+=1
-			if hudImportData['street2Seen'][player]: row[12]+=1
-			if hudImportData['street3Seen'][player]: row[13]+=1
-			if hudImportData['street4Seen'][player]: row[14]+=1
-			if hudImportData['sawShowdown'][player]: row[15]+=1
-			if hudImportData['street1Aggr'][player]: row[16]+=1
-			if hudImportData['street2Aggr'][player]: row[17]+=1
-			if hudImportData['street3Aggr'][player]: row[18]+=1
-			if hudImportData['street4Aggr'][player]: row[19]+=1
-			if hudImportData['otherRaisedStreet1'][player]: row[20]+=1
-			if hudImportData['otherRaisedStreet2'][player]: row[21]+=1
-			if hudImportData['otherRaisedStreet3'][player]: row[22]+=1
-			if hudImportData['otherRaisedStreet4'][player]: row[23]+=1
-			if hudImportData['foldToOtherRaisedStreet1'][player]: row[24]+=1
-			if hudImportData['foldToOtherRaisedStreet2'][player]: row[25]+=1
-			if hudImportData['foldToOtherRaisedStreet3'][player]: row[26]+=1
-			if hudImportData['foldToOtherRaisedStreet4'][player]: row[27]+=1
-			if hudImportData['wonWhenSeenStreet1'][player]!=0.0: row[28]+=hudImportData['wonWhenSeenStreet1'][player]
-			if hudImportData['wonAtSD'][player]!=0.0: row[29]+=hudImportData['wonAtSD'][player]
-			if hudImportData['stealAttemptChance'][player]: row[30]+=1
-			if hudImportData['stealAttempted'][player]: row[31]+=1
-			if hudImportData['foldBbToStealChance'][player]: row[32]+=1
-			if hudImportData['foldedBbToSteal'][player]: row[33]+=1
-			if hudImportData['foldSbToStealChance'][player]: row[34]+=1
-			if hudImportData['foldedSbToSteal'][player]: row[35]+=1
-			
-			if hudImportData['street1CBChance'][player]: row[36]+=1
-			if hudImportData['street1CBDone'][player]: row[37]+=1
-			if hudImportData['street2CBChance'][player]: row[38]+=1
-			if hudImportData['street2CBDone'][player]: row[39]+=1
-			if hudImportData['street3CBChance'][player]: row[40]+=1
-			if hudImportData['street3CBDone'][player]: row[41]+=1
-			if hudImportData['street4CBChance'][player]: row[42]+=1
-			if hudImportData['street4CBDone'][player]: row[43]+=1
-			
-			if hudImportData['foldToStreet1CBChance'][player]: row[44]+=1
-			if hudImportData['foldToStreet1CBDone'][player]: row[45]+=1
-			if hudImportData['foldToStreet2CBChance'][player]: row[46]+=1
-			if hudImportData['foldToStreet2CBDone'][player]: row[47]+=1
-			if hudImportData['foldToStreet3CBChance'][player]: row[48]+=1
-			if hudImportData['foldToStreet3CBDone'][player]: row[49]+=1
-			if hudImportData['foldToStreet4CBChance'][player]: row[50]+=1
-			if hudImportData['foldToStreet4CBDone'][player]: row[51]+=1
-
-			row[52]+=hudImportData['totalProfit'][player]
-
-			if hudImportData['street1CheckCallRaiseChance'][player]: row[53]+=1
-			if hudImportData['street1CheckCallRaiseDone'][player]: row[54]+=1
-			if hudImportData['street2CheckCallRaiseChance'][player]: row[55]+=1
-			if hudImportData['street2CheckCallRaiseDone'][player]: row[56]+=1
-			if hudImportData['street3CheckCallRaiseChance'][player]: row[57]+=1
-			if hudImportData['street3CheckCallRaiseDone'][player]: row[58]+=1
-			if hudImportData['street4CheckCallRaiseChance'][player]: row[59]+=1
-			if hudImportData['street4CheckCallRaiseDone'][player]: row[60]+=1
-			
-			if doInsert:
-				#print "playerid before insert:",row[2]
-				cursor.execute("""INSERT INTO HudCache
-					(gametypeId, playerId, activeSeats, position, tourneyTypeId, 
-					HDs, street0VPI, street0Aggr, street0_3B4BChance, street0_3B4BDone,
-					street1Seen, street2Seen, street3Seen, street4Seen, sawShowdown,
-					street1Aggr, street2Aggr, street3Aggr, street4Aggr, otherRaisedStreet1,
-					otherRaisedStreet2, otherRaisedStreet3, otherRaisedStreet4, foldToOtherRaisedStreet1, foldToOtherRaisedStreet2, 
-					foldToOtherRaisedStreet3, foldToOtherRaisedStreet4, wonWhenSeenStreet1, wonAtSD, stealAttemptChance, 
-					stealAttempted, foldBbToStealChance, foldedBbToSteal, foldSbToStealChance, foldedSbToSteal, 
-					street1CBChance, street1CBDone, street2CBChance, street2CBDone, street3CBChance, 
-					street3CBDone, street4CBChance, street4CBDone, foldToStreet1CBChance, foldToStreet1CBDone, 
-					foldToStreet2CBChance, foldToStreet2CBDone, foldToStreet3CBChance, foldToStreet3CBDone, foldToStreet4CBChance, 
-					foldToStreet4CBDone, totalProfit, street1CheckCallRaiseChance, street1CheckCallRaiseDone, street2CheckCallRaiseChance, 
-					street2CheckCallRaiseDone, street3CheckCallRaiseChance, street3CheckCallRaiseDone, street4CheckCallRaiseChance, street4CheckCallRaiseDone)
-					VALUES (%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s, 
-					%s, %s, %s, %s, %s)""", (row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19], row[20], row[21], row[22], row[23], row[24], row[25], row[26], row[27], row[28], row[29], row[30], row[31], row[32], row[33], row[34], row[35], row[36], row[37], row[38], row[39], row[40], row[41], row[42], row[43], row[44], row[45], row[46], row[47], row[48], row[49], row[50], row[51], row[52], row[53], row[54], row[55], row[56], row[57], row[58], row[59], row[60]))
-			else:
-				#print "storing updated hud data line"
-				cursor.execute("""UPDATE HudCache
-					SET HDs=%s, street0VPI=%s, street0Aggr=%s, street0_3B4BChance=%s, street0_3B4BDone=%s, 
-					street1Seen=%s, street2Seen=%s, street3Seen=%s, street4Seen=%s, sawShowdown=%s, 
-					street1Aggr=%s, street2Aggr=%s, street3Aggr=%s, street4Aggr=%s, otherRaisedStreet1=%s, 
-					otherRaisedStreet2=%s, otherRaisedStreet3=%s, otherRaisedStreet4=%s, foldToOtherRaisedStreet1=%s, foldToOtherRaisedStreet2=%s, 
-					foldToOtherRaisedStreet3=%s, foldToOtherRaisedStreet4=%s, wonWhenSeenStreet1=%s, wonAtSD=%s, stealAttemptChance=%s, 
-					stealAttempted=%s, foldBbToStealChance=%s, foldedBbToSteal=%s, foldSbToStealChance=%s, foldedSbToSteal=%s, 
-					street1CBChance=%s, street1CBDone=%s, street2CBChance=%s, street2CBDone=%s, street3CBChance=%s, 
-					street3CBDone=%s, street4CBChance=%s, street4CBDone=%s, foldToStreet1CBChance=%s, foldToStreet1CBDone=%s, 
-					foldToStreet2CBChance=%s, foldToStreet2CBDone=%s, foldToStreet3CBChance=%s, foldToStreet3CBDone=%s, foldToStreet4CBChance=%s, 
-					foldToStreet4CBDone=%s, totalProfit=%s, street1CheckCallRaiseChance=%s, street1CheckCallRaiseDone=%s, street2CheckCallRaiseChance=%s, 
-					street2CheckCallRaiseDone=%s, street3CheckCallRaiseChance=%s, street3CheckCallRaiseDone=%s, street4CheckCallRaiseChance=%s, street4CheckCallRaiseDone=%s
-					WHERE gametypeId=%s AND playerId=%s AND activeSeats=%s AND position=%s AND tourneyTypeId=%s""", (row[6], row[7], row[8], row[9], row[10], 
-					row[11], row[12], row[13], row[14], row[15], 
-					row[16], row[17], row[18], row[19], row[20], 
-					row[21], row[22], row[23], row[24], row[25], 
-					row[26], row[27], row[28], row[29], row[30], 
-					row[31], row[32], row[33], row[34], row[35], row[36], row[37], row[38], row[39], row[40], 
-					row[41], row[42], row[43], row[44], row[45], row[46], row[47], row[48], row[49], row[50], 
-					row[51], row[52], row[53], row[54], row[55], row[56], row[57], row[58], row[59], row[60], 
-					row[1], row[2], row[3], str(row[4]), row[5]))
-#	else:
-#		print "todo: implement storeHudCache for stud base"
-#end def storeHudCache
-
-def store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, startTime):
-	cursor.execute("SELECT id FROM Tourneys WHERE siteTourneyNo=%s AND tourneyTypeId=%s", (siteTourneyNo, tourneyTypeId))
-	tmp=cursor.fetchone()
-	#print "tried SELECTing tourneys.id, result:",tmp
-	
-	try:
-		len(tmp)
-	except TypeError:#means we have to create new one
-		cursor.execute("""INSERT INTO Tourneys
-		(tourneyTypeId, siteTourneyNo, entries, prizepool, startTime)
-		VALUES (%s, %s, %s, %s, %s)""", (tourneyTypeId, siteTourneyNo, entries, prizepool, startTime))
-		cursor.execute("SELECT id FROM Tourneys WHERE siteTourneyNo=%s AND tourneyTypeId=%s", (siteTourneyNo, tourneyTypeId))
-		tmp=cursor.fetchone()
-		#print "created new tourneys.id:",tmp
-	return tmp[0]
-#end def store_tourneys
-
-def store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings):
-	result=[]
-	#print "in store_tourneys_players. tourney_id:",tourney_id
-	#print "player_ids:",player_ids
-	#print "payin_amounts:",payin_amounts
-	#print "ranks:",ranks
-	#print "winnings:",winnings
-	for i in range (len(player_ids)):
-		cursor.execute("SELECT id FROM TourneysPlayers WHERE tourneyId=%s AND playerId=%s", (tourney_id, player_ids[i]))
-		tmp=cursor.fetchone()
-		#print "tried SELECTing tourneys_players.id:",tmp
-		
-		try:
-			len(tmp)
-		except TypeError:
-			cursor.execute("""INSERT INTO TourneysPlayers
-			(tourneyId, playerId, payinAmount, rank, winnings) VALUES (%s, %s, %s, %s, %s)""",
-			(tourney_id, player_ids[i], payin_amounts[i], ranks[i], winnings[i]))
-			
-			cursor.execute("SELECT id FROM TourneysPlayers WHERE tourneyId=%s AND playerId=%s",
-						   (tourney_id, player_ids[i]))
-			tmp=cursor.fetchone()
-			#print "created new tourneys_players.id:",tmp
-		result.append(tmp[0])
-	return result
-#end def store_tourneys_players
+#!/usr/bin/python
+ 
+#Copyright 2008 Steffen Jobbagy-Felso
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU Affero General Public License as published by
+#the Free Software Foundation, version 3 of the License.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU Affero General Public License
+#along with this program. If not, see <http://www.gnu.org/licenses/>.
+#In the "official" distribution you can find the license in
+#agpl-3.0.txt in the docs folder of the package.
+ 
+#This file contains simple functions for fpdb
+ 
+import datetime
+import re
+ 
+PS=1
+FTP=2
+
+MYSQL_INNODB=2
+PGSQL=3
+SQLITE=4
+
+
+class DuplicateError(Exception):
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return repr(self.value)
+ 
+class FpdbError(Exception):
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return repr(self.value)
+ 
+# gets value for last auto-increment key generated
+# returns -1 if a problem occurs
+def getLastInsertId(backend, conn, cursor):
+    if backend == MYSQL_INNODB:
+        ret = conn.insert_id()
+        if ret < 1 or ret > 999999999:
+            print "getLastInsertId(): problem fetching insert_id? ret=", ret
+            ret = -1
+    elif backend == PGSQL:
+        # some options:
+        # currval(hands_id_seq) - use name of implicit seq here
+        # lastval() - still needs sequences set up?
+        # insert ... returning  is useful syntax (but postgres specific?)
+        # see rules (fancy trigger type things)
+        cursor.execute ("SELECT lastval()")
+        row = cursor.fetchone()
+        if not row:
+            print "getLastInsertId(%s): problem fetching lastval? row=" % seq, row
+            ret = -1
+        else:
+            ret = row[0]
+    elif backend == SQLITE:
+        # don't know how to do this in sqlite
+        print "getLastInsertId(): not coded for sqlite yet"
+        ret = -1
+    else:
+        print "getLastInsertId(): unknown backend ", backend
+        ret = -1
+    return ret
+#end def getLastInsertId
+ 
+#returns an array of the total money paid. intending to add rebuys/addons here
+def calcPayin(count, buyin, fee):
+    result=[]
+    for i in range(count):
+        result.append (buyin+fee)
+    return result
+#end def calcPayin
+ 
+def checkPositions(positions):
+    """verifies that these positions are valid"""
+    for i in range (len(positions)):
+        pos=positions[i]
+        try:#todo: use type recognition instead of error
+            if (len(pos)!=1):
+                raise FpdbError("invalid position found in checkPositions. i: "+str(i)+" position: "+pos) #dont need to str() here
+        except TypeError:#->not string->is int->fine
+            pass
+        
+        ### RHH modified to allow for "position 9" here (pos==9 is when you're a dead hand before the BB
+        if (pos!="B" and pos!="S" and pos!=0 and pos!=1 and pos!=2 and pos!=3 and pos!=4 and pos!=5 and pos!=6 and pos!=7 and pos!=9):
+            raise FpdbError("invalid position found in checkPositions. i: "+str(i)+" position: "+str(pos))
+#end def fpdb_simple.checkPositions
+ 
+#classifies each line for further processing in later code. Manipulates the passed arrays.
+def classifyLines(hand, category, lineTypes, lineStreets):
+    currentStreet="predeal"
+    done=False #set this to true once we reach the last relevant line (the summary, except rake, is all repeats)
+    for i in range (len(hand)):
+        if (done):
+            if (hand[i].find("[")==-1 or hand[i].find("mucked [")==-1):
+                lineTypes.append("ignore")
+            else: #it's storing a mucked card
+                lineTypes.append("cards")
+        elif (hand[i].startswith("Dealt to")):
+            lineTypes.append("cards")
+        elif (i==0):
+            lineTypes.append("header")
+        elif (hand[i].startswith("Seat ") and ((hand[i].find("in chips")!=-1) or (hand[i].find("($")!=-1))):
+            lineTypes.append("name")
+        elif (isActionLine(hand[i])):
+            lineTypes.append("action")
+            if (hand[i].find(" posts ")!=-1 or hand[i].find(" posts the ")!=-1):#need to set this here so the "action" of posting blinds is registered properly
+                currentStreet="preflop"
+        elif (isWinLine(hand[i])):
+            lineTypes.append("win")
+        elif (hand[i].startswith("Total pot ") and hand[i].find("Rake")!=-1):
+            lineTypes.append("rake")
+            done=True
+        elif (hand[i]=="*** SHOW DOWN ***" or hand[i]=="*** SUMMARY ***"):
+            lineTypes.append("ignore")
+            #print "in classifyLine, showdown or summary"
+        elif (hand[i].find(" antes ")!=-1 or hand[i].find(" posts the ante ")!=-1):
+            lineTypes.append("ante")
+        elif (hand[i].startswith("*** FLOP *** [")):
+            lineTypes.append("cards")
+            currentStreet="flop"
+        elif (hand[i].startswith("*** TURN *** [")):
+            lineTypes.append("cards")
+            currentStreet="turn"
+        elif (hand[i].startswith("*** RIVER *** [")):
+            lineTypes.append("cards")
+            currentStreet="river"
+        elif (hand[i].startswith("*** 3")):
+            lineTypes.append("ignore")
+            currentStreet=0
+        elif (hand[i].startswith("*** 4")):
+            lineTypes.append("ignore")
+            currentStreet=1
+        elif (hand[i].startswith("*** 5")):
+            lineTypes.append("ignore")
+            currentStreet=2
+        elif (hand[i].startswith("*** 6")):
+            lineTypes.append("ignore")
+            currentStreet=3
+        elif (hand[i].startswith("*** 7") or hand[i]=="*** RIVER ***"):
+            lineTypes.append("ignore")
+            currentStreet=4
+        elif (hand[i].find(" shows [")!=-1):
+            lineTypes.append("cards")
+        elif (hand[i].startswith("Table '")):
+            lineTypes.append("table")
+        else:
+            raise FpdbError("unrecognised linetype in:"+hand[i])
+        lineStreets.append(currentStreet)
+#end def classifyLines
+ 
+def convert3B4B(site, category, limit_type, actionTypes, actionAmounts):
+    """calculates the actual bet amounts in the given amount array and changes it accordingly."""
+    for i in range (len(actionTypes)):
+        for j in range (len(actionTypes[i])):
+            bets=[]
+            for k in range (len(actionTypes[i][j])):
+                if (actionTypes[i][j][k]=="bet"):
+                    bets.append((i,j,k))
+                    if (len(bets)==2):
+                        #print "len(bets) 2 or higher, need to correct it. bets:",bets,"len:",len(bets)
+                        amount2=actionAmounts[bets[1][0]][bets[1][1]][bets[1][2]]
+                        amount1=actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]
+                        actionAmounts[bets[1][0]][bets[1][1]][bets[1][2]]=amount2-amount1
+                    elif (len(bets)>2):
+                        fail=True
+                        #todo: run correction for below
+                        if (site=="ps" and category=="holdem" and limit_type=="nl" and len(bets)==3):
+                            fail=False
+                        if (site=="ftp" and category=="omahahi" and limit_type=="pl" and len(bets)==3):
+                            fail=False
+                        
+                        if fail:
+                            print "len(bets)>2 in convert3B4B, i didnt think this is possible. i:",i,"j:",j,"k:",k
+                            print "actionTypes:",actionTypes
+                            raise FpdbError ("too many bets in convert3B4B")
+    #print "actionAmounts postConvert",actionAmounts
+#end def convert3B4B(actionTypes, actionAmounts)
+ 
+#Corrects the bet amount if the player had to pay blinds
+def convertBlindBet(actionTypes, actionAmounts):
+    i=0#setting street to pre-flop
+    for j in range (len(actionTypes[i])):#playerloop
+        blinds=[]
+        bets=[]
+        for k in range (len(actionTypes[i][j])):
+            if (actionTypes[i][j][k]=="blind"):
+                blinds.append((i,j,k))
+            
+            if (len(blinds)>0 and actionTypes[i][j][k]=="bet"):
+                bets.append((i,j,k))
+                if (len(bets)==1):
+                    blind_amount=actionAmounts[blinds[0][0]][blinds[0][1]][blinds[0][2]]
+                    bet_amount=actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]
+                    actionAmounts[bets[0][0]][bets[0][1]][bets[0][2]]=bet_amount-blind_amount
+#end def convertBlindBet
+ 
+#converts the strings in the given array to ints (changes the passed array, no returning). see table design for conversion details
+#todo: make this use convertCardValuesBoard
+def convertCardValues(arr):
+    for i in range (len(arr)):
+        for j in range (len(arr[i])):
+            if (arr[i][j]=="A"):
+                arr[i][j]=14
+            elif (arr[i][j]=="K"):
+                arr[i][j]=13
+            elif (arr[i][j]=="Q"):
+                arr[i][j]=12
+            elif (arr[i][j]=="J"):
+                arr[i][j]=11
+            elif (arr[i][j]=="T"):
+                arr[i][j]=10
+            else:
+                arr[i][j]=int(arr[i][j])
+#end def convertCardValues
+ 
+#converts the strings in the given array to ints (changes the passed array, no returning). see table design for conversion details
+def convertCardValuesBoard(arr):
+    for i in range (len(arr)):
+        if (arr[i]=="A"):
+            arr[i]=14
+        elif (arr[i]=="K"):
+            arr[i]=13
+        elif (arr[i]=="Q"):
+            arr[i]=12
+        elif (arr[i]=="J"):
+            arr[i]=11
+        elif (arr[i]=="T"):
+            arr[i]=10
+        else:
+            arr[i]=int(arr[i])
+#end def convertCardValuesBoard
+ 
+#this creates the 2D/3D arrays. manipulates the passed arrays instead of returning.
+def createArrays(category, seats, card_values, card_suits, antes, winnings, rakes, action_types, allIns, action_amounts, actionNos, actionTypeByNo):
+    for i in range(seats):#create second dimension arrays
+        tmp=[]
+        card_values.append(tmp)
+        tmp=[]
+        card_suits.append(tmp)
+        antes.append(0)
+        winnings.append(0)
+        rakes.append(0)
+    
+    if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
+        streetCount=4
+    else:
+        streetCount=5
+    
+    for i in range(streetCount): #build the first dimension array, for streets
+        tmp=[]
+        action_types.append(tmp)
+        tmp=[]
+        allIns.append(tmp)
+        tmp=[]
+        action_amounts.append(tmp)
+        tmp=[]
+        actionNos.append(tmp)
+        tmp=[]
+        actionTypeByNo.append(tmp)
+        for j in range (seats): #second dimension arrays: players
+            tmp=[]
+            action_types[i].append(tmp)
+            tmp=[]
+            allIns[i].append(tmp)
+            tmp=[]
+            action_amounts[i].append(tmp)
+            tmp=[]
+            actionNos[i].append(tmp)
+    if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
+        pass
+    elif (category=="razz" or category=="studhi" or category=="studhilo"):#need to fill card arrays.
+        for i in range(seats):
+            for j in range (7):
+                card_values[i].append(0)
+                card_suits[i].append("x")
+    else:
+        raise FpdbError("invalid category")
+#end def createArrays
+ 
+def fill_board_cards(board_values, board_suits):
+#fill up the two board card arrays
+    while (len(board_values)<5):
+        board_values.append(0)
+        board_suits.append("x")
+#end def fill_board_cards
+ 
+def fillCardArrays(player_count, base, category, card_values, card_suits):
+    """fills up the two card arrays"""
+    if (category=="holdem"):
+        cardCount=2
+    elif (category=="omahahi" or category=="omahahilo"):
+        cardCount=4
+    elif base=="stud":
+        cardCount=7
+    else:
+        raise fpdb_simple.FpdbError ("invalid category:", category)
+    
+    for i in range (player_count):
+        while (len(card_values[i])<cardCount):
+            card_values[i].append(0)
+            card_suits[i].append("x")
+#end def fillCardArrays
+ 
+#filters out a player that folded before paying ante or blinds. This should be called
+#before calling the actual hand parser. manipulates hand, no return.
+def filterAnteBlindFold(site,hand):
+    #todo: this'll only get rid of one ante folder, not multiple ones
+    #todo: in tourneys this should not be removed but
+    #print "start of filterAnteBlindFold"
+    pre3rd=[]
+    for i in range (len(hand)):
+        if (hand[i].startswith("*** 3") or hand[i].startswith("*** HOLE")):
+            pre3rd=hand[0:i]
+    
+    foldeeName=None
+    for i in range (len(pre3rd)):
+        if (pre3rd[i].endswith("folds") or pre3rd[i].endswith("is sitting out") or pre3rd[i].endswith(" stands up")): #found ante fold or timeout
+            pos=pre3rd[i].find (" folds")
+            foldeeName=pre3rd[i][0:pos]
+            if pos==-1 and pre3rd[i].find(" in chips)")==-1:
+                pos=pre3rd[i].find (" is sitting out")
+                foldeeName=pre3rd[i][0:pos]
+            if pos==-1:
+                pos=pre3rd[i].find (" stands up")
+                foldeeName=pre3rd[i][0:pos]
+            if pos==-1:#this one is for PS tourney
+                pos1=pre3rd[i].find (": ")+2
+                pos2=pre3rd[i].find (" (")
+                foldeeName=pre3rd[i][pos1:pos2]
+ 
+    if foldeeName!=None:
+        #print "filterAnteBlindFold, foldeeName:",foldeeName
+        toRemove=[]
+        for i in range (len(hand)): #using hand again to filter from all streets, just in case.
+            #todo: this will break it if sittin out BB wins a hand
+            if (hand[i].find(foldeeName)!=-1):
+                toRemove.append(hand[i])
+            
+        for i in range (len(toRemove)):
+            hand.remove(toRemove[i])
+#end def filterAnteFold
+ 
+#removes useless lines as well as trailing spaces
+def filterCrap(site, hand, isTourney):
+    #remove two trailing spaces at end of line
+    for i in range (len(hand)):
+        if (hand[i][-1]==' '):
+            hand[i]=hand[i][:-1]
+        if (hand[i][-1]==' '):
+            hand[i]=hand[i][:-1]
+            
+    #print "hand after trailing space removal in filterCrap:",hand
+    #general variable position word filter/string filter
+    toRemove=[]
+    for i in range (len(hand)):
+        if (hand[i].startswith("Board [")):
+            toRemove.append(hand[i])
+        elif (hand[i].find(" out of hand ")!=-1):
+            hand[i]=hand[i][:-56]
+        elif (hand[i].find("($0 in chips)") != -1):
+            toRemove.append(hand[i])
+        elif (hand[i]=="*** HOLE CARDS ***"):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has been disconnected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has requested TIME")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has returned")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("will be allowed to play after the button")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has timed out")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has timed out while disconnected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has timed out while being disconnected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("is connected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("is disconnected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" is feeling angry")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" is feeling confused")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" is feeling happy")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" is feeling normal")):
+            toRemove.append(hand[i])
+        elif (hand[i].find(" is low with [")!=-1):
+            toRemove.append(hand[i])
+        #elif (hand[i].find("-max Seat #")!=-1 and hand[i].find(" is the button")!=-1):
+        # toRemove.append(hand[i])
+        elif (hand[i].endswith(" mucks")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(": mucks hand")):
+            toRemove.append(hand[i])
+        elif (hand[i]=="No low hand qualified"):
+            toRemove.append(hand[i])
+        elif (hand[i]=="Pair on board - a double bet is allowed"):
+            toRemove.append(hand[i])
+        elif (hand[i].find(" shows ")!=-1 and hand[i].find("[")==-1):
+            toRemove.append(hand[i])
+        #elif (hand[i].startswith("Table '") and hand[i].endswith("-max")):
+        # toRemove.append(hand[i])
+        elif (hand[i].startswith("The button is in seat #")):
+            toRemove.append(hand[i])
+        #above is alphabetic, reorder below if bored
+        elif (hand[i].startswith("Time has expired")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("has reconnected")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("seconds left to act")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("seconds to reconnect")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("was removed from the table for failing to post")):
+            toRemove.append(hand[i])
+        elif (hand[i].find("joins the table at seat ")!=-1):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" sits down")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("leaves the table")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith(" stands up")):
+            toRemove.append(hand[i])
+        elif (hand[i].find("is high with ")!=-1):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("doesn't show hand")):
+            toRemove.append(hand[i])
+        elif (hand[i].endswith("is being treated as all-in")):
+            toRemove.append(hand[i])
+        elif (hand[i].find(" adds $")!=-1):
+            toRemove.append(hand[i])
+        elif (hand[i]=="Betting is capped"):
+            toRemove.append(hand[i])
+        #site specific variable position filter
+        elif (hand[i].find(" said, \"")!=-1):
+            toRemove.append(hand[i])
+        elif (hand[i].find(": ")!=-1 and site=="ftp" and hand[i].find("Seat ")==-1 and hand[i].find(": Table")==-1): #filter ftp chat
+            toRemove.append(hand[i])
+        if isTourney:
+            if (hand[i].endswith(" is sitting out") and (not hand[i].startswith("Seat "))):
+                toRemove.append(hand[i])
+        else:
+            if (hand[i].endswith(": sits out")):
+                toRemove.append(hand[i])
+            elif (hand[i].endswith(" is sitting out")):
+                toRemove.append(hand[i])
+ 
+    
+    for i in range (len(toRemove)):
+        #print "removing in filterCr:",toRemove[i]
+        hand.remove(toRemove[i])
+    
+    #print "done with filterCrap, hand:", hand
+    return hand
+#end filterCrap
+ 
+#takes a poker float (including , for thousand seperator and converts it to an int
+def float2int (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:]
+    
+    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
+ 
+#returns boolean whether the passed line is an action line
+def isActionLine(line):
+    if (line.endswith("folds")):
+        return True
+    elif (line.endswith("checks")):
+        return True
+    elif (line.find("calls $")!=-1 or line.find(": calls ")!=-1):
+        return True
+    elif (line.find("brings in for")!=-1):
+        return True
+    elif (line.find("completes it to")!=-1):
+        return True
+    elif (line.find("posts small blind")!=-1):
+        return True
+    elif (line.find("posts the small blind")!=-1):
+        return True
+    elif (line.find("posts big blind")!=-1):
+        return True
+    elif (line.find("posts the big blind")!=-1):
+        return True
+    elif (line.find("posts small & big blinds")!=-1):
+        return True
+    elif (line.find(" posts $")!=-1): #this reads voluntary blind pay in FTP Holdem
+        return True
+    elif (line.find(" posts a dead ")!=-1): #this reads voluntary blind pay in FTP Holdem
+        return True
+    elif (line.find("bets $")!=-1 or line.find(": bets ")!=-1):
+        return True
+    elif (line.find("raises")!=-1):
+        return True
+    elif (line.startswith("Uncalled bet")):
+        return True
+    else:
+        return False
+#end def isActionLine
+ 
+#returns whether this is a duplicate
+def isAlreadyInDB(cursor, gametypeID, siteHandNo):
+    #print "isAlreadyInDB gtid,shand:",gametypeID, siteHandNo
+    cursor.execute ("SELECT id FROM Hands WHERE gametypeId=%s AND siteHandNo=%s", (gametypeID, siteHandNo))
+    result=cursor.fetchall()
+    if (len(result)>=1):
+        raise DuplicateError ("dupl")
+#end isAlreadyInDB
+ 
+def isRebuyOrAddon(topline):
+    """isRebuyOrAddon not implemented yet"""
+    return False
+#end def isRebuyOrAddon
+ 
+#returns whether the passed topline indicates a tournament or not
+def isTourney(topline):
+    if (topline.find("Tournament")!=-1):
+        return True
+    else:
+        return False
+#end def isTourney
+ 
+#returns boolean whether the passed line is a win line
+def isWinLine(line):
+    if (line.find("wins the pot")!=-1):
+        return True
+    elif (line.find("ties for the high pot")!=-1):
+        return True
+    elif (line.find("ties for the high main pot")!=-1):
+        return True
+    elif (line.find("ties for the high side pot")!=-1):
+        return True
+    elif (line.find("ties for the low pot")!=-1):
+        return True
+    elif (line.find("ties for the low main pot")!=-1):
+        return True
+    elif (line.find("ties for the low side pot")!=-1):
+        return True
+    elif (line.find("ties for the main pot")!=-1): #for ftp tied main pot of split pot
+        return True
+    elif (line.find("ties for the pot")!=-1): #for ftp tie
+        return True
+    elif (line.find("ties for the side pot")!=-1): #for ftp tied split pots
+        return True
+    elif (line.find("wins side pot #")!=-1): #for ftp multi split pots
+        return True
+    elif (line.find("wins the low main pot")!=-1):
+        return True
+    elif (line.find("wins the low pot")!=-1):
+        return True
+    elif (line.find("wins the low side pot")!=-1):
+        return True
+    elif (line.find("wins the high main pot")!=-1):
+        return True
+    elif (line.find("wins the high pot")!=-1):
+        return True
+    elif (line.find("wins the high side pot")!=-1):
+        return True
+    elif (line.find("wins the main pot")!=-1):
+        return True
+    elif (line.find("wins the side pot")!=-1): #for ftp split pots
+        return True
+    elif (line.find("collected")!=-1):
+        return True
+    else:
+        return False #not raising error here, any unknown line wouldve been detected in isActionLine already
+#end def isWinLine
+ 
+#returns the amount of cash/chips put into the put in the given action line
+def parseActionAmount(line, atype, site, isTourney):
+    #if (line.endswith(" and is all-in")):
+    # line=line[:-14]
+    #elif (line.endswith(", and is all in")):
+    # line=line[:-15]
+    
+    if line.endswith(", and is capped"):#ideally we should recognise this as an all-in if category is capXl
+        line=line[:-15]
+    if line.endswith(" and is capped"):
+        line=line[:-14]
+ 
+    
+    if (atype=="fold"):
+        amount=0
+    elif (atype=="check"):
+        amount=0
+    elif (atype=="unbet" and site=="ftp"):
+        pos1=line.find("$")+1
+        pos2=line.find(" returned to")
+        amount=float2int(line[pos1:pos2])
+    elif (atype=="unbet" and site=="ps"):
+        #print "ps unbet, line:",line
+        pos1=line.find("$")+1
+        if pos1==0:
+            pos1=line.find("(")+1
+        pos2=line.find(")")
+        amount=float2int(line[pos1:pos2])
+    elif (atype=="bet" and site=="ps" and line.find(": raises $")!=-1 and line.find("to $")!=-1):
+        pos=line.find("to $")+4
+        amount=float2int(line[pos:])
+    else:
+        if not isTourney:
+            pos=line.rfind("$")+1
+            #print "parseActionAmount, line:", line, "line[pos:]:", line[pos:]
+            amount=float2int(line[pos:])
+        else:
+            #print "line:"+line+"EOL"
+            pos=line.rfind(" ")+1
+            #print "pos:",pos
+            #print "pos of 20:", line.find("20")
+            amount=int(line[pos:])
+    
+    if atype=="unbet":
+        amount*=-1
+    return amount
+#end def parseActionAmount
+ 
+#doesnt return anything, simply changes the passed arrays action_types and
+# action_amounts. For stud this expects numeric streets (3-7), for
+# holdem/omaha it expects predeal, preflop, flop, turn or river
+def parseActionLine(site, base, isTourney, line, street, playerIDs, names, action_types, allIns, action_amounts, actionNos, actionTypeByNo):
+    if (street=="predeal" or street=="preflop"):
+        street=0
+    elif (street=="flop"):
+        street=1
+    elif (street=="turn"):
+        street=2
+    elif (street=="river"):
+        street=3
+    
+    nextActionNo=0
+    for player in range(len(actionNos[street])):
+        for count in range(len(actionNos[street][player])):
+            if actionNos[street][player][count]>=nextActionNo:
+                nextActionNo=actionNos[street][player][count]+1
+                
+    line, allIn=goesAllInOnThisLine(line)
+    atype=parseActionType(line)
+    playerno=recognisePlayerNo(line, names, atype)
+    amount=parseActionAmount(line, atype, site, isTourney)
+    
+    action_types[street][playerno].append(atype)
+    allIns[street][playerno].append(allIn)
+    action_amounts[street][playerno].append(amount)
+    actionNos[street][playerno].append(nextActionNo)
+    tmp=(playerIDs[playerno], atype)
+    actionTypeByNo[street].append(tmp)
+#end def parseActionLine
+ 
+def goesAllInOnThisLine(line):
+    """returns whether the player went all-in on this line and removes the all-in text from the line."""
+    isAllIn=False
+    if (line.endswith(" and is all-in")):
+        line=line[:-14]
+        isAllIn=True
+    elif (line.endswith(", and is all in")):
+        line=line[:-15]
+        isAllIn=True
+    return (line, isAllIn)
+#end def goesAllInOnThisLine
+ 
+#returns the action type code (see table design) of the given action line
+def parseActionType(line):
+    if (line.startswith("Uncalled bet")):
+        return "unbet"
+    elif (line.endswith("folds")):
+        return "fold"
+    elif (line.endswith("checks")):
+        return "check"
+    elif (line.find("calls")!=-1):
+        return "call"
+    elif (line.find("brings in for")!=-1):
+        return "blind"
+    elif (line.find("completes it to")!=-1):
+        return "bet"
+       #todo: what if someone completes instead of bringing in?
+    elif (line.find(" posts $")!=-1):
+        return "blind"
+    elif (line.find(" posts a dead ")!=-1):
+        return "blind"
+    elif (line.find(": posts small blind ")!=-1):
+        return "blind"
+    elif (line.find(" posts the small blind of $")!=-1):
+        return "blind"
+    elif (line.find(": posts big blind ")!=-1):
+        return "blind"
+    elif (line.find(" posts the big blind of $")!=-1):
+        return "blind"
+    elif (line.find(": posts small & big blinds $")!=-1):
+        return "blind"
+    #todo: seperately record voluntary blind payments made to join table out of turn
+    elif (line.find("bets")!=-1):
+        return "bet"
+    elif (line.find("raises")!=-1):
+        return "bet"
+    else:
+        raise FpdbError ("failed to recognise actiontype in parseActionLine in: "+line)
+#end def parseActionType
+ 
+#parses the ante out of the given line and checks which player paid it, updates antes accordingly.
+def parseAnteLine(line, site, isTourney, names, antes):
+    for i in range(len(names)):
+        if (line.startswith(names[i].encode("latin-1"))): #found the ante'er
+            pos=line.rfind("$")+1
+            if not isTourney:
+                antes[i]+=float2int(line[pos:])
+            else:
+                if line.find("all-in")==-1:
+                    pos=line.rfind(" ")+1
+                    antes[i]+=int(line[pos:])
+                else:
+                    pos1=line.rfind("ante")+5
+                    pos2=line.find(" ",pos1)
+                    antes[i]+=int(line[pos1:pos2])
+        #print "parseAnteLine line: ", line, "antes[i]", antes[i], "antes", antes
+#end def parseAntes
+ 
+#returns the buyin of a tourney in cents
+def parseBuyin(topline):
+    pos1=topline.find("$")+1
+    pos2=topline.find("+")
+    return float2int(topline[pos1:pos2])
+#end def parseBuyin
+ 
+#parses a card line and changes the passed arrays accordingly
+#todo: reorganise this messy method
+def parseCardLine(site, category, street, line, names, cardValues, cardSuits, boardValues, boardSuits):
+    if (line.startswith("Dealt to ") or line.find(" shows [")!=-1 or line.find("mucked [")!=-1):
+        playerNo=recognisePlayerNo(line, names, "card") #anything but unbet will be ok for that string
+ 
+        pos=line.rfind("[")+1
+        if (category=="holdem"):
+            for i in (pos, pos+3):
+                cardValues[playerNo].append(line[i:i+1])
+                cardSuits[playerNo].append(line[i+1:i+2])
+            if (len(cardValues[playerNo])!=2):
+                if cardValues[playerNo][0]==cardValues[playerNo][2] and cardSuits[playerNo][1]==cardSuits[playerNo][3]: #two tests will do
+                    cardValues[playerNo]=cardValues[playerNo][0:2]
+                    cardSuits[playerNo]=cardSuits[playerNo][0:2]
+                else:
+                    print "line:",line,"cardValues[playerNo]:",cardValues[playerNo]
+                    raise FpdbError("read too many/too few holecards in parseCardLine")
+        elif (category=="omahahi" or category=="omahahilo"):
+            for i in (pos, pos+3, pos+6, pos+9):
+                cardValues[playerNo].append(line[i:i+1])
+                cardSuits[playerNo].append(line[i+1:i+2])
+            if (len(cardValues[playerNo])!=4):
+                if cardValues[playerNo][0]==cardValues[playerNo][4] and cardSuits[playerNo][3]==cardSuits[playerNo][7]: #two tests will do
+                    cardValues[playerNo]=cardValues[playerNo][0:4]
+                    cardSuits[playerNo]=cardSuits[playerNo][0:4]
+                else:
+                    print "line:",line,"cardValues[playerNo]:",cardValues[playerNo]
+                    raise FpdbError("read too many/too few holecards in parseCardLine")
+        elif (category=="razz" or category=="studhi" or category=="studhilo"):
+            if (line.find("shows")==-1):
+                #print "parseCardLine(in stud if), street:", street
+                if line[pos+2]=="]": #-> not (hero and 3rd street)
+                    cardValues[playerNo][street+2]=line[pos:pos+1]
+                    cardSuits[playerNo][street+2]=line[pos+1:pos+2]
+                else:
+                    #print "hero card1:", line[pos:pos+2], "hero card2:", line[pos+3:pos+5], "hero card3:", line[pos+6:pos+8],
+                    cardValues[playerNo][street]=line[pos:pos+1]
+                    cardSuits[playerNo][street]=line[pos+1:pos+2]
+                    cardValues[playerNo][street+1]=line[pos+3:pos+4]
+                    cardSuits[playerNo][street+1]=line[pos+4:pos+5]
+                    cardValues[playerNo][street+2]=line[pos+6:pos+7]
+                    cardSuits[playerNo][street+2]=line[pos+7:pos+8]
+            else:
+                #print "parseCardLine(in stud else), street:", street
+                cardValues[playerNo][0]=line[pos:pos+1]
+                cardSuits[playerNo][0]=line[pos+1:pos+2]
+                pos+=3
+                cardValues[playerNo][1]=line[pos:pos+1]
+                cardSuits[playerNo][1]=line[pos+1:pos+2]
+                if street==4:
+                    pos=pos=line.rfind("]")-2
+                    cardValues[playerNo][6]=line[pos:pos+1]
+                    cardSuits[playerNo][6]=line[pos+1:pos+2]
+                    #print "cardValues:", cardValues
+                    #print "cardSuits:", cardSuits
+        else:
+            print "line:",line,"street:",street
+            raise FpdbError("invalid category")
+        #print "end of parseCardLine/playercards, cardValues:",cardValues
+    elif (line.startswith("*** FLOP ***")):
+        pos=line.find("[")+1
+        for i in (pos, pos+3, pos+6):
+            boardValues.append(line[i:i+1])
+            boardSuits.append(line[i+1:i+2])
+        #print boardValues
+    elif (line.startswith("*** TURN ***") or line.startswith("*** RIVER ***")):
+        pos=line.find("[")+1
+        pos=line.find("[", pos+1)+1
+        boardValues.append(line[pos:pos+1])
+        boardSuits.append(line[pos+1:pos+2])
+        #print boardValues
+    else:
+        raise FpdbError ("unrecognised line:"+line)
+#end def parseCardLine
+ 
+def parseCashesAndSeatNos(lines, site):
+    """parses the startCashes and seatNos of each player out of the given lines and returns them as a dictionary of two arrays"""
+    cashes = []
+    seatNos = []
+    for i in range (len(lines)):
+        pos2=lines[i].find(":")
+        seatNos.append(int(lines[i][5:pos2]))
+        
+        pos1=lines[i].rfind("($")+2
+        if pos1==1: #for tourneys - it's 1 instead of -1 due to adding 2 above
+            pos1=lines[i].rfind("(")+1
+        if (site=="ftp"):
+            pos2=lines[i].rfind(")")
+        elif (site=="ps"):
+            pos2=lines[i].find(" in chips")
+        cashes.append(float2int(lines[i][pos1:pos2]))
+    return {'startCashes':cashes, 'seatNos':seatNos}
+#end def parseCashesAndSeatNos
+ 
+#returns the buyin of a tourney in cents
+def parseFee(topline):
+    pos1=topline.find("$")+1
+    pos1=topline.find("$",pos1)+1
+    pos2=topline.find(" ", pos1)
+    return float2int(topline[pos1:pos2])
+#end def parsefee
+ 
+#returns a datetime object with the starttime indicated in the given topline
+def parseHandStartTime(topline, site):
+    #convert x:13:35 to 0x:13:35
+    counter=0
+    while (True):
+        pos=topline.find(" "+str(counter)+":")
+        if (pos!=-1):
+            topline=topline[0:pos+1]+"0"+topline[pos+1:]
+        counter+=1
+        if counter==10: break
+    
+    isUTC=False
+    if site=="ftp":
+        pos = topline.find(" ", len(topline)-26)+1
+        tmp = topline[pos:]
+        #print "year:", tmp[14:18], "month", tmp[19:21], "day", tmp[22:24], "hour", tmp[0:2], "minute", tmp[3:5], "second", tmp[6:8]
+        result = datetime.datetime(int(tmp[14:18]), int(tmp[19:21]), int(tmp[22:24]), int(tmp[0:2]), int(tmp[3:5]), int(tmp[6:8]))
+    elif site=="ps":
+        if topline.find("UTC")!=-1:
+            pos1 = topline.find("-")+2
+            pos2 = topline.find("UTC")
+            tmp=topline[pos1:pos2]
+            isUTC=True
+        else:
+            tmp=topline[-30:]
+            #print "parsehandStartTime, tmp:", tmp
+            pos = tmp.find("-")+2
+            tmp = tmp[pos:]
+        #Need to match either
+        # 2008/09/07 06:23:14 ET or
+        # 2008/08/17 - 01:14:43 (ET)
+        m = re.match('(?P<YEAR>[0-9]{4})\/(?P<MON>[0-9]{2})\/(?P<DAY>[0-9]{2})[\- ]+(?P<HR>[0-9]{2}):(?P<MIN>[0-9]{2}):(?P<SEC>[0-9]{2})',tmp)
+        #print "year:", int(m.group('YEAR')), "month", int(m.group('MON')), "day", int(m.group('DAY')), "hour", int(m.group('HR')), "minute", int(m.group('MIN')), "second", int(m.group('SEC'))
+        result = datetime.datetime(int(m.group('YEAR')), int(m.group('MON')), int(m.group('DAY')), int(m.group('HR')), int(m.group('MIN')), int(m.group('SEC')))
+    else:
+        raise FpdbError("invalid site in parseHandStartTime")
+    
+    if (site=="ftp" or site=="ps") and not isUTC: #these use US ET
+        result+=datetime.timedelta(hours=5)
+    
+    return result
+#end def parseHandStartTime
+ 
+#parses the names out of the given lines and returns them as an array
+def parseNames(lines):
+    result = []
+    for i in range (len(lines)):
+        pos1=lines[i].find(":")+2
+        pos2=lines[i].rfind("(")-1
+        tmp=lines[i][pos1:pos2]
+        #print "parseNames, tmp original:",tmp
+        tmp=unicode(tmp,"latin-1")
+        #print "parseNames, tmp after unicode latin-1 conversion:",tmp
+        result.append(tmp)
+    return result
+#end def parseNames
+ 
+#returns an array with the positions of the respective players
+def parsePositions (hand, names):
+    #prep array
+    positions=[]
+    for i in range(len(names)):
+        positions.append(-1)
+    
+    #find blinds
+    sb,bb=-1,-1
+    for i in range (len(hand)):
+        if (sb==-1 and hand[i].find("small blind")!=-1 and hand[i].find("dead small blind")==-1):
+            sb=hand[i]
+            #print "sb:",sb
+        if (bb==-1 and hand[i].find("big blind")!=-1 and hand[i].find("dead big blind")==-1):
+            bb=hand[i]
+            #print "bb:",bb
+ 
+    #identify blinds
+    #print "parsePositions before recognising sb/bb. names:",names
+    sbExists=True
+    if (sb!=-1):
+        sb=recognisePlayerNo(sb, names, "bet")
+    else:
+        sbExists=False
+    if (bb!=-1):
+        bb=recognisePlayerNo(bb, names, "bet")
+    
+    #write blinds into array
+    if (sbExists):
+        positions[sb]="S"
+    positions[bb]="B"
+    
+    #fill up rest of array
+    if (sbExists):
+        arraypos=sb-1
+    else:
+        arraypos=bb-1
+    distFromBtn=0
+    while (arraypos>=0 and arraypos != bb):
+        #print "parsePositions first while, arraypos:",arraypos,"positions:",positions
+        positions[arraypos]=distFromBtn
+        arraypos-=1
+        distFromBtn+=1
+ 
+    ### RHH - Changed to set the null seats before BB to "9"
+    i=bb-1
+    while positions[i] < 0:
+        positions[i]=9
+        i-=1
+    
+    arraypos=len(names)-1
+    if (bb!=0 or (bb==0 and sbExists==False)):
+        while (arraypos>bb):
+            positions[arraypos]=distFromBtn
+            arraypos-=1
+            distFromBtn+=1
+            
+    for i in range (len(names)):
+        if positions[i]==-1:
+            print "parsePositions names:",names
+            print "result:",positions
+            raise FpdbError ("failed to read positions")
+    return positions
+#end def parsePositions
+ 
+#simply parses the rake amount and returns it as an int
+def parseRake(line):
+    pos=line.find("Rake")+6
+    rake=float2int(line[pos:])
+    return rake
+#end def parseRake
+ 
+def parseSiteHandNo(topline):
+    """returns the hand no assigned by the poker site"""
+    pos1=topline.find("#")+1
+    pos2=topline.find(":")
+    return topline[pos1:pos2]
+#end def parseSiteHandNo
+ 
+def parseTableLine(site, base, line):
+    """returns a dictionary with maxSeats and tableName"""
+    if site=="ps":
+        pos1=line.find('\'')+1
+        pos2=line.find('\'', pos1)
+        #print "table:",line[pos1:pos2]
+        pos3=pos2+2
+        pos4=line.find("-max")
+        #print "seats:",line[pos3:pos4]
+        return {'maxSeats':int(line[pos3:pos4]), 'tableName':line[pos1:pos2]}
+    elif site=="ftp":
+        pos1=line.find("Table ")+6
+        pos2=line.find("-")-1
+        if base=="hold":
+            maxSeats=9
+        elif base=="stud":
+            maxSeats=8
+            
+        if line.find("6 max")!=-1:
+            maxSeats=6
+        elif line.find("4 max")!=-1:
+            maxSeats=4
+        elif line.find("heads up")!=-1:
+            maxSeats=2
+            
+        return {'maxSeats':maxSeats, 'tableName':line[pos1:pos2]}
+    else:
+        raise FpdbError("invalid site ID")
+#end def parseTableLine
+ 
+#returns the hand no assigned by the poker site
+def parseTourneyNo(topline):
+    pos1=topline.find("Tournament #")+12
+    pos2=topline.find(",", pos1)
+    #print "parseTourneyNo pos1:",pos1," pos2:",pos2, " result:",topline[pos1:pos2]
+    return topline[pos1:pos2]
+#end def parseTourneyNo
+ 
+#parses a win/collect line. manipulates the passed array winnings, no explicit return
+def parseWinLine(line, site, names, winnings, isTourney):
+    #print "parseWinLine: line:",line
+    for i in range(len(names)):
+        if (line.startswith(names[i].encode("latin-1"))): #found a winner
+            if isTourney:
+                pos1=line.rfind("collected ")+10
+                if (site=="ftp"):
+                    pos2=line.find(")", pos1)
+                elif (site=="ps"):
+                    pos2=line.find(" ", pos1)
+                winnings[i]+=int(line[pos1:pos2])
+            else:
+                pos1=line.rfind("$")+1
+                if (site=="ftp"):
+                    pos2=line.find(")", pos1)
+                elif (site=="ps"):
+                    pos2=line.find(" ", pos1)
+                winnings[i]+=float2int(line[pos1:pos2])
+#end def parseWinLine
+ 
+#returns the category (as per database) string for the given line
+def recogniseCategory(line):
+    if (line.find("Razz")!=-1):
+        return "razz"
+    elif (line.find("Hold'em")!=-1):
+        return "holdem"
+    elif (line.find("Omaha")!=-1 and line.find("Hi/Lo")==-1 and line.find("H/L")==-1):
+        return "omahahi"
+    elif (line.find("Omaha")!=-1 and (line.find("Hi/Lo")!=-1 or line.find("H/L")!=-1)):
+        return "omahahilo"
+    elif (line.find("Stud")!=-1 and line.find("Hi/Lo")==-1 and line.find("H/L")==-1):
+        return "studhi"
+    elif (line.find("Stud")!=-1 and (line.find("Hi/Lo")!=-1 or line.find("H/L")!=-1)):
+        return "studhilo"
+    else:
+        raise FpdbError("failed to recognise category, line:"+line)
+#end def recogniseCategory
+ 
+#returns the int for the gametype_id for the given line
+def recogniseGametypeID(backend, db, cursor, topline, smallBlindLine, site_id, category, isTourney):#todo: this method is messy
+    #if (topline.find("HORSE")!=-1):
+    # raise FpdbError("recogniseGametypeID: HORSE is not yet supported.")
+    
+    #note: the below variable names small_bet and big_bet are misleading, in NL/PL they mean small/big blind
+    if isTourney:
+        type="tour"
+        pos1=topline.find("(")+1
+        if (topline[pos1]=="H" or topline[pos1]=="O" or topline[pos1]=="R" or topline[pos1]=="S" or topline[pos1+2]=="C"):
+            pos1=topline.find("(", pos1)+1
+        pos2=topline.find("/", pos1)
+        small_bet=int(topline[pos1:pos2])
+    else:
+        type="ring"
+        pos1=topline.find("$")+1
+        pos2=topline.find("/$")
+        small_bet=float2int(topline[pos1:pos2])
+    
+    pos1=pos2+2
+    if isTourney:
+        pos1-=1
+    if (site_id==1): #ftp
+        pos2=topline.find(" ", pos1)
+    elif (site_id==2): #ps
+        pos2=topline.find(")")
+    
+    if pos2<=pos1:
+        pos2=topline.find(")", pos1)
+    
+    if isTourney:
+        big_bet=int(topline[pos1:pos2])
+    else:
+        big_bet=float2int(topline[pos1:pos2])
+    
+    if (topline.find("No Limit")!=-1):
+        limit_type="nl"
+        if (topline.find("Cap No")!=-1):
+            limit_type="cn"
+    elif (topline.find("Pot Limit")!=-1):
+        limit_type="pl"
+        if (topline.find("Cap Pot")!=-1):
+            limit_type="cp"
+    else:
+        limit_type="fl"
+    
+    #print "recogniseGametypeID small_bet/blind:",small_bet,"big bet/blind:", big_bet,"limit type:",limit_type
+    if (limit_type=="fl"):
+        cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBet=%s AND bigBet=%s", (site_id, type, category, limit_type, small_bet, big_bet))
+    else:
+        cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s AND limitType=%s AND smallBlind=%s AND bigBlind=%s", (site_id, type, category, limit_type, small_bet, big_bet))
+    result=cursor.fetchone()
+    #print "recgt1 result=",result
+    #ret=result[0]
+    #print "recgt1 ret=",ret
+    #print "tried SELECTing gametypes.id, result:",result
+    
+    try:
+        len(result)
+    except TypeError:
+        if category=="holdem" or category=="omahahi" or category=="omahahilo":
+            base="hold"
+        else:
+            base="stud"
+        
+        if category=="holdem" or category=="omahahi" or category=="studhi":
+            hiLo='h'
+        elif category=="razz":
+            hiLo='l'
+        else:
+            hiLo='s'
+        
+        if (limit_type=="fl"):
+            big_blind=small_bet
+            if base=="hold":
+                if smallBlindLine==topline:
+                    raise FpdbError("invalid small blind line")
+                elif isTourney:
+                    pos=smallBlindLine.rfind(" ")+1
+                    small_blind=int(smallBlindLine[pos:])
+                else:
+                    pos=smallBlindLine.rfind("$")+1
+                    small_blind=float2int(smallBlindLine[pos:])
+            else:
+                small_blind=0
+            cursor.execute( """INSERT INTO Gametypes(siteId, type, base, category, limitType
+                                                    ,hiLo, smallBlind, bigBlind, smallBet, bigBet)
+                               VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"""
+                          , (site_id, type, base, category, limit_type, hiLo
+                            ,small_blind, big_blind, small_bet, big_bet) )
+            #cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s 
+            #AND limitType=%s AND smallBet=%s AND bigBet=%s", (site_id, type, category, limit_type, small_bet, big_bet))
+        else:
+            cursor.execute( """INSERT INTO Gametypes(siteId, type, base, category, limitType
+                                                    ,hiLo, smallBlind, bigBlind, smallBet, bigBet)
+                               VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"""
+                          , (site_id, type, base, category, limit_type
+                            ,hiLo, small_bet, big_bet, 0, 0))#remember, for these bet means blind
+            #cursor.execute ("SELECT id FROM Gametypes WHERE siteId=%s AND type=%s AND category=%s
+            #AND limitType=%s AND smallBlind=%s AND bigBlind=%s", (site_id, type, category, limit_type, small_bet, big_bet))
+ 
+        #result=(db.insert_id(),)
+        result=(getLastInsertId(backend,db,cursor),)
+    
+    return result[0]
+#end def recogniseGametypeID
+ 
+def recogniseTourneyTypeId(cursor, siteId, buyin, fee, knockout, rebuyOrAddon):
+    cursor.execute ("SELECT id FROM TourneyTypes WHERE siteId=%s AND buyin=%s AND fee=%s AND knockout=%s AND rebuyOrAddon=%s", (siteId, buyin, fee, knockout, rebuyOrAddon))
+    result=cursor.fetchone()
+    #print "tried SELECTing gametypes.id, result:",result
+    
+    try:
+        len(result)
+    except TypeError:#this means we need to create a new entry
+        cursor.execute("""INSERT INTO TourneyTypes (siteId, buyin, fee, knockout, rebuyOrAddon) VALUES (%s, %s, %s, %s, %s)""", (siteId, buyin, fee, knockout, rebuyOrAddon))
+        cursor.execute("SELECT id FROM TourneyTypes WHERE siteId=%s AND buyin=%s AND fee=%s AND knockout=%s AND rebuyOrAddon=%s", (siteId, buyin, fee, knockout, rebuyOrAddon))
+        result=cursor.fetchone()
+    return result[0]
+#end def recogniseTourneyTypeId
+ 
+#returns the SQL ids of the names given in an array
+def recognisePlayerIDs(cursor, names, site_id):
+    result = []
+    for i in range (len(names)):
+        cursor.execute ("SELECT id FROM Players WHERE name=%s", (names[i],))
+        tmp=cursor.fetchall()
+        if (len(tmp)==0): #new player
+            cursor.execute ("INSERT INTO Players (name, siteId) VALUES (%s, %s)", (names[i], site_id))
+            #print "Number of players rows inserted: %d" % cursor.rowcount
+            cursor.execute ("SELECT id FROM Players WHERE name=%s", (names[i],))
+            tmp=cursor.fetchall()
+        #print "recognisePlayerIDs, names[i]:",names[i],"tmp:",tmp
+        result.append(tmp[0][0])
+    return result
+#end def recognisePlayerIDs
+ 
+#recognises the name in the given line and returns its array position in the given array
+def recognisePlayerNo(line, names, atype):
+    #print "recogniseplayerno, names:",names
+    for i in range (len(names)):
+        if (atype=="unbet"):
+            if (line.endswith(names[i].encode("latin-1"))):
+                return (i)
+        elif (line.startswith("Dealt to ")):
+            #print "recognisePlayerNo, card precut, line:",line
+            tmp=line[9:]
+            #print "recognisePlayerNo, card postcut, tmp:",tmp
+            if (tmp.startswith(names[i].encode("latin-1"))):
+                return (i)
+        elif (line.startswith("Seat ")):
+            if (line.startswith("Seat 10")):
+                tmp=line[9:]
+            else:
+                tmp=line[8:]
+            
+            if (tmp.startswith(names[i].encode("latin-1"))):
+                return (i)
+        else:
+            if (line.startswith(names[i].encode("latin-1"))):
+                return (i)
+    #if we're here we mustve failed
+    raise FpdbError ("failed to recognise player in: "+line+" atype:"+atype)
+#end def recognisePlayerNo
+ 
+#returns the site abbreviation for the given site
+def recogniseSite(line):
+    if (line.startswith("Full Tilt Poker")):
+        return "ftp"
+    elif (line.startswith("PokerStars")):
+        return "ps"
+    else:
+        raise FpdbError("failed to recognise site, line:"+line)
+#end def recogniseSite
+ 
+#returns the ID of the given site
+def recogniseSiteID(cursor, site):
+    if (site=="ftp"):
+        return 1
+        #cursor.execute("SELECT id FROM Sites WHERE name = ('Full Tilt Poker')")
+    elif (site=="ps"):
+        return 2
+        #cursor.execute("SELECT id FROM Sites WHERE name = ('PokerStars')")
+    else:
+        raise FpdbError("invalid site in recogniseSiteID: "+site)
+    return cursor.fetchall()[0][0]
+#end def recogniseSiteID
+ 
+#removes trailing \n from the given array
+def removeTrailingEOL(arr):
+    for i in range(len(arr)):
+        if (arr[i].endswith("\n")):
+            #print "arr[i] before removetrailingEOL:", arr[i]
+            arr[i]=arr[i][:-1]
+            #print "arr[i] after removetrailingEOL:", arr[i]
+    return arr
+#end def removeTrailingEOL
+ 
+#splits the rake according to the proportion of pot won. manipulates the second passed array.
+def splitRake(winnings, rakes, totalRake):
+    winnercnt=0
+    totalWin=0
+    for i in range(len(winnings)):
+        if winnings[i]!=0:
+            winnercnt+=1
+            totalWin+=winnings[i]
+            firstWinner=i
+    if winnercnt==1:
+        rakes[firstWinner]=totalRake
+    else:
+        totalWin=float(totalWin)
+        for i in range(len(winnings)):
+            if winnings[i]!=0:
+                winPortion=winnings[i]/totalWin
+                rakes[i]=totalRake*winPortion
+#end def splitRake
+ 
+def storeActions(cursor, handsPlayersIds, actionTypes, allIns, actionAmounts, actionNos):
+#stores into table hands_actions
+    #print "start of storeActions, actionNos:",actionNos
+    #print " action_amounts:",action_amounts
+    for i in range (len(actionTypes)): #iterate through streets
+        for j in range (len(actionTypes[i])): #iterate through names
+            for k in range (len(actionTypes[i][j])): #iterate through individual actions of that player on that street
+                cursor.execute ("INSERT INTO HandsActions (handPlayerId, street, actionNo, action, allIn, amount) VALUES (%s, %s, %s, %s, %s, %s)"
+                               , (handsPlayersIds[j], i, actionNos[i][j][k], actionTypes[i][j][k], allIns[i][j][k], actionAmounts[i][j][k]))
+#end def storeActions
+ 
+def store_board_cards(cursor, hands_id, board_values, board_suits):
+#stores into table board_cards
+    cursor.execute ("""INSERT INTO BoardCards (handId, card1Value, card1Suit,
+card2Value, card2Suit, card3Value, card3Suit, card4Value, card4Suit,
+card5Value, card5Suit) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
+    (hands_id, board_values[0], board_suits[0], board_values[1], board_suits[1],
+    board_values[2], board_suits[2], board_values[3], board_suits[3],
+    board_values[4], board_suits[4]))
+#end def store_board_cards
+ 
+def storeHands(backend, conn, cursor, site_hand_no, gametype_id
+              ,hand_start_time, names, tableName, maxSeats):
+#stores into table hands
+    cursor.execute ("INSERT INTO Hands (siteHandNo, gametypeId, handStart, seats, tableName, importTime, maxSeats) VALUES (%s, %s, %s, %s, %s, %s, %s)", (site_hand_no, gametype_id, hand_start_time, len(names), tableName, datetime.datetime.today(), maxSeats))
+    #todo: find a better way of doing this...
+    #cursor.execute("SELECT id FROM Hands WHERE siteHandNo=%s AND gametypeId=%s", (site_hand_no, gametype_id))
+    #return cursor.fetchall()[0][0]
+    return getLastInsertId(backend, conn, cursor)
+    #return db.insert_id() # mysql only
+#end def storeHands
+ 
+def store_hands_players_holdem_omaha(backend, conn, cursor, category, hands_id, player_ids, start_cashes
+                                    ,positions, card_values, card_suits, winnings, rakes, seatNos):
+    result=[]
+    if (category=="holdem"):
+        for i in range (len(player_ids)):
+            cursor.execute ("""
+INSERT INTO HandsPlayers
+(handId, playerId, startCash, position,
+card1Value, card1Suit, card2Value, card2Suit, winnings, rake, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
+            (hands_id, player_ids[i], start_cashes[i], positions[i],
+            card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+            winnings[i], rakes[i], seatNos[i]))
+            #cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId=%s", (hands_id, player_ids[i]))
+            #result.append(cursor.fetchall()[0][0])
+            result.append( getLastInsertId(backend, conn, cursor) ) # mysql only
+    elif (category=="omahahi" or category=="omahahilo"):
+        for i in range (len(player_ids)):
+            cursor.execute ("""INSERT INTO HandsPlayers
+(handId, playerId, startCash, position,
+card1Value, card1Suit, card2Value, card2Suit,
+card3Value, card3Suit, card4Value, card4Suit, winnings, rake, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
+            (hands_id, player_ids[i], start_cashes[i], positions[i],
+            card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+            card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
+            winnings[i], rakes[i], seatNos[i]))
+            #cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId+0=%s", (hands_id, player_ids[i]))
+            #result.append(cursor.fetchall()[0][0])
+            result.append( getLastInsertId(backend, conn, cursor) ) # mysql only
+    else:
+        raise FpdbError("invalid category")
+    return result
+#end def store_hands_players_holdem_omaha
+ 
+def store_hands_players_stud(backend, conn, cursor, hands_id, player_ids, start_cashes, antes,
+                             card_values, card_suits, winnings, rakes, seatNos):
+#stores hands_players rows for stud/razz games. returns an array of the resulting IDs
+    result=[]
+    #print "before inserts in store_hands_players_stud, antes:", antes
+    for i in range (len(player_ids)):
+        cursor.execute ("""INSERT INTO HandsPlayers
+(handId, playerId, startCash, ante,
+card1Value, card1Suit, card2Value, card2Suit,
+card3Value, card3Suit, card4Value, card4Suit,
+card5Value, card5Suit, card6Value, card6Suit,
+card7Value, card7Suit, winnings, rake, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
+%s, %s, %s, %s)""",
+        (hands_id, player_ids[i], start_cashes[i], antes[i],
+        card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+        card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
+        card_values[i][4], card_suits[i][4], card_values[i][5], card_suits[i][5],
+        card_values[i][6], card_suits[i][6], winnings[i], rakes[i], seatNos[i]))
+        #cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId+0=%s", (hands_id, player_ids[i]))
+        #result.append(cursor.fetchall()[0][0])
+        result.append( getLastInsertId(backend, conn, cursor) ) # mysql only
+    return result
+#end def store_hands_players_stud
+ 
+def store_hands_players_holdem_omaha_tourney(backend, conn, cursor, category, hands_id, player_ids
+                                            ,start_cashes, positions, card_values, card_suits
+                                            , winnings, rakes, seatNos, tourneys_players_ids):
+    #stores hands_players for tourney holdem/omaha hands
+    result=[]
+    for i in range (len(player_ids)):
+        if len(card_values[0])==2:
+            cursor.execute ("""INSERT INTO HandsPlayers
+(handId, playerId, startCash, position,
+card1Value, card1Suit, card2Value, card2Suit,
+winnings, rake, tourneysPlayersId, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
+            (hands_id, player_ids[i], start_cashes[i], positions[i],
+            card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+            winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
+        elif len(card_values[0])==4:
+            cursor.execute ("""INSERT INTO HandsPlayers
+(handId, playerId, startCash, position,
+card1Value, card1Suit, card2Value, card2Suit,
+card3Value, card3Suit, card4Value, card4Suit,
+winnings, rake, tourneysPlayersId, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
+            (hands_id, player_ids[i], start_cashes[i], positions[i],
+            card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+            card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
+            winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
+        else:
+            raise FpdbError ("invalid card_values length:"+str(len(card_values[0])))
+        #cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId+0=%s", (hands_id, player_ids[i]))
+        #result.append(cursor.fetchall()[0][0])
+        result.append( getLastInsertId(backend, conn, cursor) ) # mysql only
+    
+    return result
+#end def store_hands_players_holdem_omaha_tourney
+ 
+def store_hands_players_stud_tourney(backend, conn, cursor, hands_id, player_ids, start_cashes,
+            antes, card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids):
+#stores hands_players for tourney stud/razz hands
+    result=[]
+    for i in range (len(player_ids)):
+        cursor.execute ("""INSERT INTO HandsPlayers
+(handId, playerId, startCash, ante,
+card1Value, card1Suit, card2Value, card2Suit,
+card3Value, card3Suit, card4Value, card4Suit,
+card5Value, card5Suit, card6Value, card6Suit,
+card7Value, card7Suit, winnings, rake, tourneysPlayersId, seatNo)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s, %s)""",
+        (hands_id, player_ids[i], start_cashes[i], antes[i],
+        card_values[i][0], card_suits[i][0], card_values[i][1], card_suits[i][1],
+        card_values[i][2], card_suits[i][2], card_values[i][3], card_suits[i][3],
+        card_values[i][4], card_suits[i][4], card_values[i][5], card_suits[i][5],
+        card_values[i][6], card_suits[i][6], winnings[i], rakes[i], tourneys_players_ids[i], seatNos[i]))
+        #cursor.execute("SELECT id FROM HandsPlayers WHERE handId=%s AND playerId+0=%s", (hands_id, player_ids[i]))
+        #result.append(cursor.fetchall()[0][0])
+        result.append( getLastInsertId(backend, conn, cursor) ) # mysql only
+    return result
+#end def store_hands_players_stud_tourney
+ 
+def generateHudCacheData(player_ids, base, category, action_types, allIns, actionTypeByNo
+                        ,winnings, totalWinnings, positions, actionTypes, actionAmounts):
+    """calculates data for the HUD during import. IMPORTANT: if you change this method make
+sure to also change the following storage method and table_viewer.prepare_data if necessary
+"""
+    #print "generateHudCacheData, len(player_ids)=", len(player_ids)
+    #setup subarrays of the result dictionary.
+    street0VPI=[]
+    street0Aggr=[]
+    street0_3B4BChance=[]
+    street0_3B4BDone=[]
+    street1Seen=[]
+    street2Seen=[]
+    street3Seen=[]
+    street4Seen=[]
+    sawShowdown=[]
+    street1Aggr=[]
+    street2Aggr=[]
+    street3Aggr=[]
+    street4Aggr=[]
+    otherRaisedStreet1=[]
+    otherRaisedStreet2=[]
+    otherRaisedStreet3=[]
+    otherRaisedStreet4=[]
+    foldToOtherRaisedStreet1=[]
+    foldToOtherRaisedStreet2=[]
+    foldToOtherRaisedStreet3=[]
+    foldToOtherRaisedStreet4=[]
+    wonWhenSeenStreet1=[]
+    
+    wonAtSD=[]
+    stealAttemptChance=[]
+    stealAttempted=[]
+    hudDataPositions=[]
+    
+    firstPfRaiseByNo=-1
+    firstPfRaiserId=-1
+    firstPfRaiserNo=-1
+    firstPfCallByNo=-1
+    firstPfCallerId=-1
+    for i in range(len(actionTypeByNo[0])):
+        if actionTypeByNo[0][i][1]=="bet":
+            firstPfRaiseByNo=i
+            firstPfRaiserId=actionTypeByNo[0][i][0]
+            for j in range(len(player_ids)):
+                if player_ids[j]==firstPfRaiserId:
+                    firstPfRaiserNo=j
+                    break
+            break
+    for i in range(len(actionTypeByNo[0])):
+        if actionTypeByNo[0][i][1]=="call":
+            firstPfCallByNo=i
+            firstPfCallerId=actionTypeByNo[0][i][0]
+            break
+    
+    cutoffId=-1
+    buttonId=-1
+    sbId=-1
+    bbId=-1
+    if base=="hold":
+        for player in range(len(positions)):
+            if positions==1:
+                cutoffId=player_ids[player]
+            if positions==0:
+                buttonId=player_ids[player]
+            if positions=='S':
+                sbId=player_ids[player]
+            if positions=='B':
+                bbId=player_ids[player]
+            
+    someoneStole=False
+    
+    #run a loop for each player preparing the actual values that will be commited to SQL
+    for player in range (len(player_ids)):
+        #set default values
+        myStreet0VPI=False
+        myStreet0Aggr=False
+        myStreet0_3B4BChance=False
+        myStreet0_3B4BDone=False
+        myStreet1Seen=False
+        myStreet2Seen=False
+        myStreet3Seen=False
+        myStreet4Seen=False
+        mySawShowdown=False
+        myStreet1Aggr=False
+        myStreet2Aggr=False
+        myStreet3Aggr=False
+        myStreet4Aggr=False
+        myOtherRaisedStreet1=False
+        myOtherRaisedStreet2=False
+        myOtherRaisedStreet3=False
+        myOtherRaisedStreet4=False
+        myFoldToOtherRaisedStreet1=False
+        myFoldToOtherRaisedStreet2=False
+        myFoldToOtherRaisedStreet3=False
+        myFoldToOtherRaisedStreet4=False
+        myWonWhenSeenStreet1=0.0
+        myWonAtSD=0.0
+        myStealAttemptChance=False
+        myStealAttempted=False
+        
+        #calculate VPIP and PFR
+        street=0
+        heroPfRaiseCount=0
+        for count in range (len(action_types[street][player])):#finally individual actions
+            currentAction=action_types[street][player][count]
+            if currentAction=="bet":
+                myStreet0Aggr=True
+            if (currentAction=="bet" or currentAction=="call"):
+                myStreet0VPI=True
+        
+        #PF3B4BChance and PF3B4B
+        pfFold=-1
+        pfRaise=-1
+        if firstPfRaiseByNo!=-1:
+            for i in range(len(actionTypeByNo[0])):
+                if actionTypeByNo[0][i][0]==player_ids[player]:
+                    if actionTypeByNo[0][i][1]=="bet" and pfRaise==-1 and i>firstPfRaiseByNo:
+                        pfRaise=i
+                    if actionTypeByNo[0][i][1]=="fold" and pfFold==-1:
+                        pfFold=i
+            if pfFold==-1 or pfFold>firstPfRaiseByNo:
+                myStreet0_3B4BChance=True
+                if pfRaise>firstPfRaiseByNo:
+                    myStreet0_3B4BDone=True
+        
+        #steal calculations
+        if base=="hold":
+            if len(player_ids)>=5: #no point otherwise
+                if positions[player]==1:
+                    if firstPfRaiserId==player_ids[player]:
+                        myStealAttemptChance=True
+                        myStealAttempted=True
+                    elif firstPfRaiserId==buttonId or firstPfRaiserId==sbId or firstPfRaiserId==bbId or firstPfRaiserId==-1:
+                        myStealAttemptChance=True
+                if positions[player]==0:
+                    if firstPfRaiserId==player_ids[player]:
+                        myStealAttemptChance=True
+                        myStealAttempted=True
+                    elif firstPfRaiserId==sbId or firstPfRaiserId==bbId or firstPfRaiserId==-1:
+                        myStealAttemptChance=True
+                if positions[player]=='S':
+                    if firstPfRaiserId==player_ids[player]:
+                        myStealAttemptChance=True
+                        myStealAttempted=True
+                    elif firstPfRaiserId==bbId or firstPfRaiserId==-1:
+                        myStealAttemptChance=True
+                if positions[player]=='B':
+                    pass
+            
+                if myStealAttempted:
+                    someoneStole=True
+        
+        
+        #calculate saw* values
+        isAllIn=False
+        for i in range(len(allIns[0][player])):
+            if allIns[0][player][i]:
+                isAllIn=True
+        if (len(action_types[1][player])>0 or isAllIn):
+            myStreet1Seen=True
+ 
+            for i in range(len(allIns[1][player])):
+                if allIns[1][player][i]:
+                    isAllIn=True
+            if (len(action_types[2][player])>0 or isAllIn):
+                myStreet2Seen=True
+ 
+                for i in range(len(allIns[2][player])):
+                    if allIns[2][player][i]:
+                        isAllIn=True
+                if (len(action_types[3][player])>0 or isAllIn):
+                    myStreet3Seen=True
+ 
+                    #print "base:", base
+                    if base=="hold":
+                        mySawShowdown=True
+                        for count in range (len(action_types[3][player])):
+                            if action_types[3][player][count]=="fold":
+                                mySawShowdown=False
+                    else:
+                        #print "in else"
+                        for i in range(len(allIns[3][player])):
+                            if allIns[3][player][i]:
+                                isAllIn=True
+                        if (len(action_types[4][player])>0 or isAllIn):
+                            #print "in if"
+                            myStreet4Seen=True
+ 
+                            mySawShowdown=True
+                            for count in range (len(action_types[4][player])):
+                                if action_types[4][player][count]=="fold":
+                                    mySawShowdown=False
+                        
+ 
+        #flop stuff
+        street=1
+        if myStreet1Seen:
+            for count in range(len(action_types[street][player])):
+                if action_types[street][player][count]=="bet":
+                    myStreet1Aggr=True
+            
+            for otherPlayer in range (len(player_ids)):
+                if player==otherPlayer:
+                    pass
+                else:
+                    for countOther in range (len(action_types[street][otherPlayer])):
+                        if action_types[street][otherPlayer][countOther]=="bet":
+                            myOtherRaisedStreet1=True
+                            for countOtherFold in range (len(action_types[street][player])):
+                                if action_types[street][player][countOtherFold]=="fold":
+                                    myFoldToOtherRaisedStreet1=True
+        
+        #turn stuff - copy of flop with different vars
+        street=2
+        if myStreet2Seen:
+            for count in range(len(action_types[street][player])):
+                if action_types[street][player][count]=="bet":
+                    myStreet2Aggr=True
+            
+            for otherPlayer in range (len(player_ids)):
+                if player==otherPlayer:
+                    pass
+                else:
+                    for countOther in range (len(action_types[street][otherPlayer])):
+                        if action_types[street][otherPlayer][countOther]=="bet":
+                            myOtherRaisedStreet2=True
+                            for countOtherFold in range (len(action_types[street][player])):
+                                if action_types[street][player][countOtherFold]=="fold":
+                                    myFoldToOtherRaisedStreet2=True
+        
+        #river stuff - copy of flop with different vars
+        street=3
+        if myStreet3Seen:
+            for count in range(len(action_types[street][player])):
+                if action_types[street][player][count]=="bet":
+                    myStreet3Aggr=True
+            
+            for otherPlayer in range (len(player_ids)):
+                if player==otherPlayer:
+                    pass
+                else:
+                    for countOther in range (len(action_types[street][otherPlayer])):
+                        if action_types[street][otherPlayer][countOther]=="bet":
+                            myOtherRaisedStreet3=True
+                            for countOtherFold in range (len(action_types[street][player])):
+                                if action_types[street][player][countOtherFold]=="fold":
+                                    myFoldToOtherRaisedStreet3=True
+        
+        #stud river stuff - copy of flop with different vars
+        street=4
+        if myStreet4Seen:
+            for count in range(len(action_types[street][player])):
+                if action_types[street][player][count]=="bet":
+                    myStreet4Aggr=True
+            
+            for otherPlayer in range (len(player_ids)):
+                if player==otherPlayer:
+                    pass
+                else:
+                    for countOther in range (len(action_types[street][otherPlayer])):
+                        if action_types[street][otherPlayer][countOther]=="bet":
+                            myOtherRaisedStreet4=True
+                            for countOtherFold in range (len(action_types[street][player])):
+                                if action_types[street][player][countOtherFold]=="fold":
+                                    myFoldToOtherRaisedStreet4=True
+        
+        if winnings[player]!=0:
+            if myStreet1Seen:
+                myWonWhenSeenStreet1=winnings[player]/float(totalWinnings)
+                if mySawShowdown:
+                    myWonAtSD=myWonWhenSeenStreet1
+        
+        #add each value to the appropriate array
+        street0VPI.append(myStreet0VPI)
+        street0Aggr.append(myStreet0Aggr)
+        street0_3B4BChance.append(myStreet0_3B4BChance)
+        street0_3B4BDone.append(myStreet0_3B4BDone)
+        street1Seen.append(myStreet1Seen)
+        street2Seen.append(myStreet2Seen)
+        street3Seen.append(myStreet3Seen)
+        street4Seen.append(myStreet4Seen)
+        sawShowdown.append(mySawShowdown)
+        street1Aggr.append(myStreet1Aggr)
+        street2Aggr.append(myStreet2Aggr)
+        street3Aggr.append(myStreet3Aggr)
+        street4Aggr.append(myStreet4Aggr)
+        otherRaisedStreet1.append(myOtherRaisedStreet1)
+        otherRaisedStreet2.append(myOtherRaisedStreet2)
+        otherRaisedStreet3.append(myOtherRaisedStreet3)
+        otherRaisedStreet4.append(myOtherRaisedStreet4)
+        foldToOtherRaisedStreet1.append(myFoldToOtherRaisedStreet1)
+        foldToOtherRaisedStreet2.append(myFoldToOtherRaisedStreet2)
+        foldToOtherRaisedStreet3.append(myFoldToOtherRaisedStreet3)
+        foldToOtherRaisedStreet4.append(myFoldToOtherRaisedStreet4)
+        wonWhenSeenStreet1.append(myWonWhenSeenStreet1)
+        wonAtSD.append(myWonAtSD)
+        stealAttemptChance.append(myStealAttemptChance)
+        stealAttempted.append(myStealAttempted)
+        if base=="hold":
+            pos=positions[player]
+            if pos=='B':
+                hudDataPositions.append('B')
+            elif pos=='S':
+                hudDataPositions.append('S')
+            elif pos==0:
+                hudDataPositions.append('D')
+            elif pos==1:
+                hudDataPositions.append('C')
+            elif pos>=2 and pos<=4:
+                hudDataPositions.append('M')
+            elif pos>=5 and pos<=7:
+                hudDataPositions.append('E')
+            ### RHH Added this elif to handle being a dead hand before the BB (pos==9)
+            elif pos==9:
+                hudDataPositions.append('X')
+            else:
+                raise FpdbError("invalid position")
+        elif base=="stud":
+            #todo: stud positions and steals
+            pass
+    
+    #add each array to the to-be-returned dictionary
+    result={'street0VPI':street0VPI}
+    result['street0Aggr']=street0Aggr
+    result['street0_3B4BChance']=street0_3B4BChance
+    result['street0_3B4BDone']=street0_3B4BDone
+    result['street1Seen']=street1Seen
+    result['street2Seen']=street2Seen
+    result['street3Seen']=street3Seen
+    result['street4Seen']=street4Seen
+    result['sawShowdown']=sawShowdown
+    
+    result['street1Aggr']=street1Aggr
+    result['otherRaisedStreet1']=otherRaisedStreet1
+    result['foldToOtherRaisedStreet1']=foldToOtherRaisedStreet1
+    result['street2Aggr']=street2Aggr
+    result['otherRaisedStreet2']=otherRaisedStreet2
+    result['foldToOtherRaisedStreet2']=foldToOtherRaisedStreet2
+    result['street3Aggr']=street3Aggr
+    result['otherRaisedStreet3']=otherRaisedStreet3
+    result['foldToOtherRaisedStreet3']=foldToOtherRaisedStreet3
+    result['street4Aggr']=street4Aggr
+    result['otherRaisedStreet4']=otherRaisedStreet4
+    result['foldToOtherRaisedStreet4']=foldToOtherRaisedStreet4
+    result['wonWhenSeenStreet1']=wonWhenSeenStreet1
+    result['wonAtSD']=wonAtSD
+    result['stealAttemptChance']=stealAttemptChance
+    result['stealAttempted']=stealAttempted
+    
+    #now the various steal values
+    foldBbToStealChance=[]
+    foldedBbToSteal=[]
+    foldSbToStealChance=[]
+    foldedSbToSteal=[]
+    for player in range (len(player_ids)):
+        myFoldBbToStealChance=False
+        myFoldedBbToSteal=False
+        myFoldSbToStealChance=False
+        myFoldedSbToSteal=False
+        
+        if base=="hold":
+            if someoneStole and (positions[player]=='B' or positions[player]=='S') and firstPfRaiserId!=player_ids[player]:
+                street=0
+                for count in range (len(action_types[street][player])):#individual actions
+                    if positions[player]=='B':
+                        myFoldBbToStealChance=True
+                        if action_types[street][player][count]=="fold":
+                            myFoldedBbToSteal=True
+                    if positions[player]=='S':
+                        myFoldSbToStealChance=True
+                        if action_types[street][player][count]=="fold":
+                            myFoldedSbToSteal=True
+                
+                
+        foldBbToStealChance.append(myFoldBbToStealChance)
+        foldedBbToSteal.append(myFoldedBbToSteal)
+        foldSbToStealChance.append(myFoldSbToStealChance)
+        foldedSbToSteal.append(myFoldedSbToSteal)
+    result['foldBbToStealChance']=foldBbToStealChance
+    result['foldedBbToSteal']=foldedBbToSteal
+    result['foldSbToStealChance']=foldSbToStealChance
+    result['foldedSbToSteal']=foldedSbToSteal
+    
+    #now CB
+    street1CBChance=[]
+    street1CBDone=[]
+    didStreet1CB=[]
+    for player in range (len(player_ids)):
+        myStreet1CBChance=False
+        myStreet1CBDone=False
+        
+        if street0VPI[player]:
+            myStreet1CBChance=True
+            if street1Aggr[player]:
+                myStreet1CBDone=True
+                didStreet1CB.append(player_ids[player])
+                
+        street1CBChance.append(myStreet1CBChance)
+        street1CBDone.append(myStreet1CBDone)
+    result['street1CBChance']=street1CBChance
+    result['street1CBDone']=street1CBDone
+    
+    #now 2B
+    street2CBChance=[]
+    street2CBDone=[]
+    didStreet2CB=[]
+    for player in range (len(player_ids)):
+        myStreet2CBChance=False
+        myStreet2CBDone=False
+        
+        if street1CBDone[player]:
+            myStreet2CBChance=True
+            if street2Aggr[player]:
+                myStreet2CBDone=True
+                didStreet2CB.append(player_ids[player])
+ 
+        street2CBChance.append(myStreet2CBChance)
+        street2CBDone.append(myStreet2CBDone)
+    result['street2CBChance']=street2CBChance
+    result['street2CBDone']=street2CBDone
+    
+    #now 3B
+    street3CBChance=[]
+    street3CBDone=[]
+    didStreet3CB=[]
+    for player in range (len(player_ids)):
+        myStreet3CBChance=False
+        myStreet3CBDone=False
+        
+        if street2CBDone[player]:
+            myStreet3CBChance=True
+            if street3Aggr[player]:
+                myStreet3CBDone=True
+                didStreet3CB.append(player_ids[player])
+ 
+        street3CBChance.append(myStreet3CBChance)
+        street3CBDone.append(myStreet3CBDone)
+    result['street3CBChance']=street3CBChance
+    result['street3CBDone']=street3CBDone
+    
+    #and 4B
+    street4CBChance=[]
+    street4CBDone=[]
+    didStreet4CB=[]
+    for player in range (len(player_ids)):
+        myStreet4CBChance=False
+        myStreet4CBDone=False
+        
+        if street3CBDone[player]:
+            myStreet4CBChance=True
+            if street4Aggr[player]:
+                myStreet4CBDone=True
+                didStreet4CB.append(player_ids[player])
+        
+        street4CBChance.append(myStreet4CBChance)
+        street4CBDone.append(myStreet4CBDone)
+    result['street4CBChance']=street4CBChance
+    result['street4CBDone']=street4CBDone
+ 
+ 
+    result['position']=hudDataPositions
+    
+    foldToStreet1CBChance=[]
+    foldToStreet1CBDone=[]
+    foldToStreet2CBChance=[]
+    foldToStreet2CBDone=[]
+    foldToStreet3CBChance=[]
+    foldToStreet3CBDone=[]
+    foldToStreet4CBChance=[]
+    foldToStreet4CBDone=[]
+    
+    for player in range (len(player_ids)):
+        myFoldToStreet1CBChance=False
+        myFoldToStreet1CBDone=False
+        foldToStreet1CBChance.append(myFoldToStreet1CBChance)
+        foldToStreet1CBDone.append(myFoldToStreet1CBDone)
+ 
+        myFoldToStreet2CBChance=False
+        myFoldToStreet2CBDone=False
+        foldToStreet2CBChance.append(myFoldToStreet2CBChance)
+        foldToStreet2CBDone.append(myFoldToStreet2CBDone)
+        
+        myFoldToStreet3CBChance=False
+        myFoldToStreet3CBDone=False
+        foldToStreet3CBChance.append(myFoldToStreet3CBChance)
+        foldToStreet3CBDone.append(myFoldToStreet3CBDone)
+        
+        myFoldToStreet4CBChance=False
+        myFoldToStreet4CBDone=False
+        foldToStreet4CBChance.append(myFoldToStreet4CBChance)
+        foldToStreet4CBDone.append(myFoldToStreet4CBDone)
+    
+    if len(didStreet1CB)>=1:
+        generateFoldToCB(1, player_ids, didStreet1CB, street1CBDone, foldToStreet1CBChance, foldToStreet1CBDone, actionTypeByNo)
+        
+        if len(didStreet2CB)>=1:
+            generateFoldToCB(2, player_ids, didStreet2CB, street2CBDone, foldToStreet2CBChance, foldToStreet2CBDone, actionTypeByNo)
+ 
+            if len(didStreet3CB)>=1:
+                generateFoldToCB(3, player_ids, didStreet3CB, street3CBDone, foldToStreet3CBChance, foldToStreet3CBDone, actionTypeByNo)
+ 
+                if len(didStreet4CB)>=1:
+                    generateFoldToCB(4, player_ids, didStreet4CB, street4CBDone, foldToStreet4CBChance, foldToStreet4CBDone, actionTypeByNo)
+            
+    result['foldToStreet1CBChance']=foldToStreet1CBChance
+    result['foldToStreet1CBDone']=foldToStreet1CBDone
+    result['foldToStreet2CBChance']=foldToStreet2CBChance
+    result['foldToStreet2CBDone']=foldToStreet2CBDone
+    result['foldToStreet3CBChance']=foldToStreet3CBChance
+    result['foldToStreet3CBDone']=foldToStreet3CBDone
+    result['foldToStreet4CBChance']=foldToStreet4CBChance
+    result['foldToStreet4CBDone']=foldToStreet4CBDone
+ 
+ 
+    totalProfit=[]
+    
+    street1CheckCallRaiseChance=[]
+    street1CheckCallRaiseDone=[]
+    street2CheckCallRaiseChance=[]
+    street2CheckCallRaiseDone=[]
+    street3CheckCallRaiseChance=[]
+    street3CheckCallRaiseDone=[]
+    street4CheckCallRaiseChance=[]
+    street4CheckCallRaiseDone=[]
+    #print "b4 totprof calc, len(playerIds)=", len(player_ids)
+    for pl in range (len(player_ids)):
+        #print "pl=", pl
+        myTotalProfit=winnings[pl] # still need to deduct costs
+        for i in range (len(actionTypes)): #iterate through streets
+            #for j in range (len(actionTypes[i])): #iterate through names (using pl loop above)
+                for k in range (len(actionTypes[i][pl])): #iterate through individual actions of that player on that street
+                    myTotalProfit -= actionAmounts[i][pl][k]
+        
+        myStreet1CheckCallRaiseChance=False
+        myStreet1CheckCallRaiseDone=False
+        myStreet2CheckCallRaiseChance=False
+        myStreet2CheckCallRaiseDone=False
+        myStreet3CheckCallRaiseChance=False
+        myStreet3CheckCallRaiseDone=False
+        myStreet4CheckCallRaiseChance=False
+        myStreet4CheckCallRaiseDone=False
+        
+        #print "myTotalProfit=", myTotalProfit
+        totalProfit.append(myTotalProfit)
+        #print "totalProfit[]=", totalProfit
+        
+        street1CheckCallRaiseChance.append(myStreet1CheckCallRaiseChance)
+        street1CheckCallRaiseDone.append(myStreet1CheckCallRaiseDone)
+        street2CheckCallRaiseChance.append(myStreet2CheckCallRaiseChance)
+        street2CheckCallRaiseDone.append(myStreet2CheckCallRaiseDone)
+        street3CheckCallRaiseChance.append(myStreet3CheckCallRaiseChance)
+        street3CheckCallRaiseDone.append(myStreet3CheckCallRaiseDone)
+        street4CheckCallRaiseChance.append(myStreet4CheckCallRaiseChance)
+        street4CheckCallRaiseDone.append(myStreet4CheckCallRaiseDone)
+ 
+    result['totalProfit']=totalProfit
+    #print "res[totalProfit]=", result['totalProfit']
+ 
+    result['street1CheckCallRaiseChance']=street1CheckCallRaiseChance
+    result['street1CheckCallRaiseDone']=street1CheckCallRaiseDone
+    result['street2CheckCallRaiseChance']=street2CheckCallRaiseChance
+    result['street2CheckCallRaiseDone']=street2CheckCallRaiseDone
+    result['street3CheckCallRaiseChance']=street3CheckCallRaiseChance
+    result['street3CheckCallRaiseDone']=street3CheckCallRaiseDone
+    result['street4CheckCallRaiseChance']=street4CheckCallRaiseChance
+    result['street4CheckCallRaiseDone']=street4CheckCallRaiseDone
+    return result
+#end def generateHudCacheData
+ 
+def generateFoldToCB(street, playerIDs, didStreetCB, streetCBDone, foldToStreetCBChance, foldToStreetCBDone, actionTypeByNo):
+    """fills the passed foldToStreetCB* arrays appropriately depending on the given street"""
+    #print "beginning of generateFoldToCB, street:", street, "len(actionTypeByNo):", len(actionTypeByNo)
+    #print "len(actionTypeByNo[street]):",len(actionTypeByNo[street])
+    firstCBReaction=0
+    for action in range(len(actionTypeByNo[street])):
+        if actionTypeByNo[street][action][1]=="bet":
+            for player in didStreetCB:
+                if player==actionTypeByNo[street][action][0] and firstCBReaction==0:
+                    firstCBReaction=action+1
+                    break
+    
+    for action in actionTypeByNo[street][firstCBReaction:]:
+        for player in range(len(playerIDs)):
+            if playerIDs[player]==action[0]:
+                foldToStreetCBChance[player]=True
+                if action[1]=="fold":
+                    foldToStreetCBDone[player]=True
+#end def generateFoldToCB
+ 
+def storeHudCache(cursor, base, category, gametypeId, playerIds, hudImportData):
+# if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
+        
+        #print "storeHudCache, len(playerIds)=", len(playerIds), " len(vpip)=" \
+        #, len(hudImportData['street0VPI']), " len(totprof)=", len(hudImportData['totalProfit'])
+        for player in range (len(playerIds)):
+            if base=="hold":
+                cursor.execute("SELECT * FROM HudCache WHERE gametypeId+0=%s AND playerId=%s AND activeSeats=%s AND position=%s", (gametypeId, playerIds[player], len(playerIds), hudImportData['position'][player]))
+            else:
+                cursor.execute("SELECT * FROM HudCache WHERE gametypeId+0=%s AND playerId=%s AND activeSeats=%s", (gametypeId, playerIds[player], len(playerIds)))
+            row=cursor.fetchone()
+            #print "gametypeId:", gametypeId, "playerIds[player]",playerIds[player], "len(playerIds):",len(playerIds), "row:",row
+            
+            try: len(row)
+            except TypeError:
+                row=[]
+            
+            if (len(row)==0):
+                #print "new huddata row"
+                doInsert=True
+                row=[]
+                row.append(0)#blank for id
+                row.append(gametypeId)
+                row.append(playerIds[player])
+                row.append(len(playerIds))#seats
+                for i in range(len(hudImportData)+2):
+                    row.append(0)
+                
+            else:
+                doInsert=False
+                newrow=[]
+                for i in range(len(row)):
+                    newrow.append(row[i])
+                row=newrow
+            
+            if base=="hold":
+                row[4]=hudImportData['position'][player]
+            else:
+                row[4]=0
+            row[5]=1 #tourneysGametypeId
+            row[6]+=1 #HDs
+            if hudImportData['street0VPI'][player]: row[7]+=1
+            if hudImportData['street0Aggr'][player]: row[8]+=1
+            if hudImportData['street0_3B4BChance'][player]: row[9]+=1
+            if hudImportData['street0_3B4BDone'][player]: row[10]+=1
+            if hudImportData['street1Seen'][player]: row[11]+=1
+            if hudImportData['street2Seen'][player]: row[12]+=1
+            if hudImportData['street3Seen'][player]: row[13]+=1
+            if hudImportData['street4Seen'][player]: row[14]+=1
+            if hudImportData['sawShowdown'][player]: row[15]+=1
+            if hudImportData['street1Aggr'][player]: row[16]+=1
+            if hudImportData['street2Aggr'][player]: row[17]+=1
+            if hudImportData['street3Aggr'][player]: row[18]+=1
+            if hudImportData['street4Aggr'][player]: row[19]+=1
+            if hudImportData['otherRaisedStreet1'][player]: row[20]+=1
+            if hudImportData['otherRaisedStreet2'][player]: row[21]+=1
+            if hudImportData['otherRaisedStreet3'][player]: row[22]+=1
+            if hudImportData['otherRaisedStreet4'][player]: row[23]+=1
+            if hudImportData['foldToOtherRaisedStreet1'][player]: row[24]+=1
+            if hudImportData['foldToOtherRaisedStreet2'][player]: row[25]+=1
+            if hudImportData['foldToOtherRaisedStreet3'][player]: row[26]+=1
+            if hudImportData['foldToOtherRaisedStreet4'][player]: row[27]+=1
+            if hudImportData['wonWhenSeenStreet1'][player]!=0.0: row[28]+=hudImportData['wonWhenSeenStreet1'][player]
+            if hudImportData['wonAtSD'][player]!=0.0: row[29]+=hudImportData['wonAtSD'][player]
+            if hudImportData['stealAttemptChance'][player]: row[30]+=1
+            if hudImportData['stealAttempted'][player]: row[31]+=1
+            if hudImportData['foldBbToStealChance'][player]: row[32]+=1
+            if hudImportData['foldedBbToSteal'][player]: row[33]+=1
+            if hudImportData['foldSbToStealChance'][player]: row[34]+=1
+            if hudImportData['foldedSbToSteal'][player]: row[35]+=1
+            
+            if hudImportData['street1CBChance'][player]: row[36]+=1
+            if hudImportData['street1CBDone'][player]: row[37]+=1
+            if hudImportData['street2CBChance'][player]: row[38]+=1
+            if hudImportData['street2CBDone'][player]: row[39]+=1
+            if hudImportData['street3CBChance'][player]: row[40]+=1
+            if hudImportData['street3CBDone'][player]: row[41]+=1
+            if hudImportData['street4CBChance'][player]: row[42]+=1
+            if hudImportData['street4CBDone'][player]: row[43]+=1
+            
+            if hudImportData['foldToStreet1CBChance'][player]: row[44]+=1
+            if hudImportData['foldToStreet1CBDone'][player]: row[45]+=1
+            if hudImportData['foldToStreet2CBChance'][player]: row[46]+=1
+            if hudImportData['foldToStreet2CBDone'][player]: row[47]+=1
+            if hudImportData['foldToStreet3CBChance'][player]: row[48]+=1
+            if hudImportData['foldToStreet3CBDone'][player]: row[49]+=1
+            if hudImportData['foldToStreet4CBChance'][player]: row[50]+=1
+            if hudImportData['foldToStreet4CBDone'][player]: row[51]+=1
+ 
+            #print "player=", player
+            #print "len(totalProfit)=", len(hudImportData['totalProfit'])
+            if hudImportData['totalProfit'][player]:
+                row[52]+=hudImportData['totalProfit'][player]
+ 
+            if hudImportData['street1CheckCallRaiseChance'][player]: row[53]+=1
+            if hudImportData['street1CheckCallRaiseDone'][player]: row[54]+=1
+            if hudImportData['street2CheckCallRaiseChance'][player]: row[55]+=1
+            if hudImportData['street2CheckCallRaiseDone'][player]: row[56]+=1
+            if hudImportData['street3CheckCallRaiseChance'][player]: row[57]+=1
+            if hudImportData['street3CheckCallRaiseDone'][player]: row[58]+=1
+            if hudImportData['street4CheckCallRaiseChance'][player]: row[59]+=1
+            if hudImportData['street4CheckCallRaiseDone'][player]: row[60]+=1
+            
+            if doInsert:
+                #print "playerid before insert:",row[2]
+                cursor.execute("""INSERT INTO HudCache
+(gametypeId, playerId, activeSeats, position, tourneyTypeId,
+HDs, street0VPI, street0Aggr, street0_3B4BChance, street0_3B4BDone,
+street1Seen, street2Seen, street3Seen, street4Seen, sawShowdown,
+street1Aggr, street2Aggr, street3Aggr, street4Aggr, otherRaisedStreet1,
+otherRaisedStreet2, otherRaisedStreet3, otherRaisedStreet4, foldToOtherRaisedStreet1, foldToOtherRaisedStreet2,
+foldToOtherRaisedStreet3, foldToOtherRaisedStreet4, wonWhenSeenStreet1, wonAtSD, stealAttemptChance,
+stealAttempted, foldBbToStealChance, foldedBbToSteal, foldSbToStealChance, foldedSbToSteal,
+street1CBChance, street1CBDone, street2CBChance, street2CBDone, street3CBChance,
+street3CBDone, street4CBChance, street4CBDone, foldToStreet1CBChance, foldToStreet1CBDone,
+foldToStreet2CBChance, foldToStreet2CBDone, foldToStreet3CBChance, foldToStreet3CBDone, foldToStreet4CBChance,
+foldToStreet4CBDone, totalProfit, street1CheckCallRaiseChance, street1CheckCallRaiseDone, street2CheckCallRaiseChance,
+street2CheckCallRaiseDone, street3CheckCallRaiseChance, street3CheckCallRaiseDone, street4CheckCallRaiseChance, street4CheckCallRaiseDone)
+VALUES (%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s,
+%s, %s, %s, %s, %s)""", (row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19], row[20], row[21], row[22], row[23], row[24], row[25], row[26], row[27], row[28], row[29], row[30], row[31], row[32], row[33], row[34], row[35], row[36], row[37], row[38], row[39], row[40], row[41], row[42], row[43], row[44], row[45], row[46], row[47], row[48], row[49], row[50], row[51], row[52], row[53], row[54], row[55], row[56], row[57], row[58], row[59], row[60]))
+            else:
+                #print "storing updated hud data line"
+                cursor.execute("""UPDATE HudCache
+SET HDs=%s, street0VPI=%s, street0Aggr=%s, street0_3B4BChance=%s, street0_3B4BDone=%s,
+street1Seen=%s, street2Seen=%s, street3Seen=%s, street4Seen=%s, sawShowdown=%s,
+street1Aggr=%s, street2Aggr=%s, street3Aggr=%s, street4Aggr=%s, otherRaisedStreet1=%s,
+otherRaisedStreet2=%s, otherRaisedStreet3=%s, otherRaisedStreet4=%s, foldToOtherRaisedStreet1=%s, foldToOtherRaisedStreet2=%s,
+foldToOtherRaisedStreet3=%s, foldToOtherRaisedStreet4=%s, wonWhenSeenStreet1=%s, wonAtSD=%s, stealAttemptChance=%s,
+stealAttempted=%s, foldBbToStealChance=%s, foldedBbToSteal=%s, foldSbToStealChance=%s, foldedSbToSteal=%s,
+street1CBChance=%s, street1CBDone=%s, street2CBChance=%s, street2CBDone=%s, street3CBChance=%s,
+street3CBDone=%s, street4CBChance=%s, street4CBDone=%s, foldToStreet1CBChance=%s, foldToStreet1CBDone=%s,
+foldToStreet2CBChance=%s, foldToStreet2CBDone=%s, foldToStreet3CBChance=%s, foldToStreet3CBDone=%s, foldToStreet4CBChance=%s,
+foldToStreet4CBDone=%s, totalProfit=%s, street1CheckCallRaiseChance=%s, street1CheckCallRaiseDone=%s, street2CheckCallRaiseChance=%s,
+street2CheckCallRaiseDone=%s, street3CheckCallRaiseChance=%s, street3CheckCallRaiseDone=%s, street4CheckCallRaiseChance=%s, street4CheckCallRaiseDone=%s
+WHERE gametypeId=%s AND playerId=%s AND activeSeats=%s AND position=%s AND tourneyTypeId=%s""", (row[6], row[7], row[8], row[9], row[10],
+                    row[11], row[12], row[13], row[14], row[15],
+                    row[16], row[17], row[18], row[19], row[20],
+                    row[21], row[22], row[23], row[24], row[25],
+                    row[26], row[27], row[28], row[29], row[30],
+                    row[31], row[32], row[33], row[34], row[35], row[36], row[37], row[38], row[39], row[40],
+                    row[41], row[42], row[43], row[44], row[45], row[46], row[47], row[48], row[49], row[50],
+                    row[51], row[52], row[53], row[54], row[55], row[56], row[57], row[58], row[59], row[60],
+                    row[1], row[2], row[3], str(row[4]), row[5]))
+# else:
+# print "todo: implement storeHudCache for stud base"
+#end def storeHudCache
+ 
+def store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, startTime):
+    cursor.execute("SELECT id FROM Tourneys WHERE siteTourneyNo=%s AND tourneyTypeId+0=%s", (siteTourneyNo, tourneyTypeId))
+    tmp=cursor.fetchone()
+    #print "tried SELECTing tourneys.id, result:",tmp
+    
+    try:
+        len(tmp)
+    except TypeError:#means we have to create new one
+        cursor.execute("""INSERT INTO Tourneys
+(tourneyTypeId, siteTourneyNo, entries, prizepool, startTime)
+VALUES (%s, %s, %s, %s, %s)""", (tourneyTypeId, siteTourneyNo, entries, prizepool, startTime))
+        cursor.execute("SELECT id FROM Tourneys WHERE siteTourneyNo=%s AND tourneyTypeId+0=%s", (siteTourneyNo, tourneyTypeId))
+        tmp=cursor.fetchone()
+        #print "created new tourneys.id:",tmp
+    return tmp[0]
+#end def store_tourneys
+ 
+def store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings):
+    result=[]
+    #print "in store_tourneys_players. tourney_id:",tourney_id
+    #print "player_ids:",player_ids
+    #print "payin_amounts:",payin_amounts
+    #print "ranks:",ranks
+    #print "winnings:",winnings
+    for i in range (len(player_ids)):
+        cursor.execute("SELECT id FROM TourneysPlayers WHERE tourneyId=%s AND playerId+0=%s", (tourney_id, player_ids[i]))
+        tmp=cursor.fetchone()
+        #print "tried SELECTing tourneys_players.id:",tmp
+        
+        try:
+            len(tmp)
+        except TypeError:
+            cursor.execute("""INSERT INTO TourneysPlayers
+(tourneyId, playerId, payinAmount, rank, winnings) VALUES (%s, %s, %s, %s, %s)""",
+            (tourney_id, player_ids[i], payin_amounts[i], ranks[i], winnings[i]))
+            
+            cursor.execute("SELECT id FROM TourneysPlayers WHERE tourneyId=%s AND playerId+0=%s",
+                           (tourney_id, player_ids[i]))
+            tmp=cursor.fetchone()
+            #print "created new tourneys_players.id:",tmp
+        result.append(tmp[0])
+    return result
+#end def store_tourneys_players
diff --git a/pyfpdb/upd_indexes.sql b/pyfpdb/upd_indexes.sql
new file mode 100755
index 00000000..e79f4bd4
--- /dev/null
+++ b/pyfpdb/upd_indexes.sql
@@ -0,0 +1,27 @@
+
+# script to update indexes on mysql (+other?) database
+
+select '1. Dropping indexes' as ' ';
+select 'Can''t drop messages indicate index already gone' as ' ';
+
+ALTER TABLE `fpdb`.`Settings` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Sites` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Gametypes` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Players` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Autorates` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Hands` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`BoardCards` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`TourneyTypes` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`Tourneys` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`TourneysPlayers` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`HandsPlayers` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`HandsActions` DROP INDEX `id`;
+ALTER TABLE `fpdb`.`HudCache` DROP INDEX `id`;
+
+select '2. Adding extra indexes on useful fields' as ' ';
+select 'Duplicate key name messages indicate new indexes already there' as ' '; 
+
+ALTER TABLE `fpdb`.`tourneys` ADD INDEX `siteTourneyNo`(`siteTourneyNo`);
+ALTER TABLE `fpdb`.`hands` ADD INDEX `siteHandNo`(`siteHandNo`);
+ALTER TABLE `fpdb`.`players` ADD INDEX `name`(`name`);
+
diff --git a/readme.txt b/readme.txt
new file mode 100644
index 00000000..e69de29b