From 4c0b709c22c7f5e681032626c2afc4df1a1b4742 Mon Sep 17 00:00:00 2001
From: eblade <blade.eric@gmail.com>
Date: Thu, 26 Feb 2009 22:01:35 -0500
Subject: [PATCH 01/15] fix for error if totalprofit = 0 (new player)

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

diff --git a/pyfpdb/Stats.py b/pyfpdb/Stats.py
index cad3af88..8c33f3a1 100644
--- a/pyfpdb/Stats.py
+++ b/pyfpdb/Stats.py
@@ -75,7 +75,7 @@ def totalprofit(stat_dict, player):
     if stat_dict[player]['net'] != 0:
         stat = float(stat_dict[player]['net']) / 100
         return (stat, '$%.2f' % stat, 'tp=$%.2f' % stat, 'totalprofit=$%.2f' % stat, str(stat), 'Total Profit')
-    return ('0', '0', '0', '0', 'Total Profit')
+    return ('0', '$0.00', 'tp=0', 'totalprofit=0', '0', 'Total Profit')
 
 def playername(stat_dict, player):
     """    Player Name."""

From c0400f6c66f5ddd3d6de2b4507ca74322993a51d Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Sat, 28 Feb 2009 12:34:41 +0900
Subject: [PATCH 02/15] Fix Everleaf GameInfo regex to detect FL

Added regression test mechanism while at it
---
 pyfpdb/EverleafToFpdb.py |  2 +-
 pyfpdb/RegressionTest.py | 60 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 4c565d44..4c78051f 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -28,7 +28,7 @@ class Everleaf(HandHistoryConverter):
     
     # Static regexes
     re_SplitHands  = re.compile(r"\n\n+")
-    re_GameInfo    = re.compile(r".*Blinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<LTYPE>(NL|PL)) (?P<GAME>(Hold\'em|Omaha|7 Card Stud))")
+    re_GameInfo    = re.compile(r"^(Blinds )?\$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) ((?P<LTYPE>NL|PL) )?(?P<GAME>(Hold\'em|Omaha|7 Card Stud))", re.MULTILINE)
     re_HandInfo    = re.compile(r".*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<DATETIME>\d\d\d\d/\d\d/\d\d - \d\d:\d\d:\d\d)\nTable (?P<TABLE>[- a-zA-Z]+)")
     re_Button      = re.compile(r"^Seat (?P<BUTTON>\d+) is the button", re.MULTILINE)
     re_PlayerInfo  = re.compile(r"^Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\s+(\$ (?P<CASH>[.0-9]+) USD|new player|All-in) \)", re.MULTILINE)
diff --git a/pyfpdb/RegressionTest.py b/pyfpdb/RegressionTest.py
index d52b6aca..bfbbdf5a 100755
--- a/pyfpdb/RegressionTest.py
+++ b/pyfpdb/RegressionTest.py
@@ -30,6 +30,7 @@ import fpdb_db
 import fpdb_import
 import fpdb_simple
 import FpdbSQLQueries
+import EverleafToFpdb
 import Tables
 
 import unittest
@@ -52,6 +53,8 @@ class TestSequenceFunctions(unittest.TestCase):
         self.mysqlimporter = fpdb_import.Importer(self, self.mysql_settings, self.c)
         self.mysqlimporter.setCallHud(False)
 
+        self.everleaf = EverleafToFpdb.Everleaf(self.c, "Nofile")
+
 #        """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()
@@ -110,12 +113,57 @@ class TestSequenceFunctions(unittest.TestCase):
         self.failUnless(result == "French", "French (deep) parsed incorrectly. Expected 'French' got: " + str(result))
 #        result = ("French (deep) - $0.25/$0.50 - No Limit Hold'em - Logged In As xxxx")
 
-    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 testEverleafGameInfoRegex(self):
+        cash_nlhe = """Everleaf Gaming Game #55198191
+***** Hand history for game #55198191 *****
+Blinds $0.50/$1 NL Hold'em - 2008/09/01 - 10:02:11
+Table Speed Kuala
+Seat 8 is the button
+Total number of players: 10"""
+        cash_plo = """Everleaf Gaming Game #65295370
+***** Hand history for game #65295370 *****
+Blinds $0.50/$1 PL Omaha - 2008/12/07 - 21:59:48
+Table Guanajuato
+Seat 5 is the button
+Total number of players: 6"""
+        cash_flhe = """Everleaf Gaming Game #55809022
+***** Hand history for game #55809022 *****
+$1/$2 Hold'em - 2008/09/07 - 08:04:36
+Table Jeonju
+Seat 4 is the button
+Total number of players: 5
+"""
+        #NLHE 
+        m = self.everleaf.re_GameInfo.search(cash_nlhe)
+        sb = m.group('SB')
+        bb = m.group('BB')
+        ltype = m.group('LTYPE')
+        game = m.group('GAME')
+
+        self.failUnless(sb == "0.50", "SB incorrect, expected: 0.50 got: '" + sb + "'")
+        self.failUnless(bb == "1", "BB incorrect, expected: 1 got: '" + bb + "'")
+        self.failUnless(ltype == "NL", "LTYPE incorrect, expected: NL got: '" + ltype + "'")
+        self.failUnless(game == "Hold\'em", "GAME incorrect, expected: Hold\'em got: '" + game + "'")
+
+        #FLHE
+        m = self.everleaf.re_GameInfo.search(cash_flhe)
+        sb = m.group('SB')
+        bb = m.group('BB')
+        ltype = m.group('LTYPE')
+        game = m.group('GAME')
+        print m.groups()
+
+        self.failUnless(sb == "1", "SB incorrect, expected: 1 got: '" + sb + "'")
+        self.failUnless(bb == "2", "BB incorrect, expected: 2 got: '" + bb + "'")
+        self.failUnless(ltype == None, "LTYPE incorrect, expected: NL got: '%s'" %(ltype))
+        self.failUnless(game == "Hold\'em", "GAME incorrect, expected: Hold\'em got: '" + game + "'")
+
+#    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"""

From e5c65fe036579784bd3be4b135c5cbc139a11d2f Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Sat, 28 Feb 2009 12:45:44 +0900
Subject: [PATCH 03/15] Fix Everleaf HandInfo regex to support limit

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

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 4c78051f..9655c6d8 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -29,7 +29,7 @@ class Everleaf(HandHistoryConverter):
     # Static regexes
     re_SplitHands  = re.compile(r"\n\n+")
     re_GameInfo    = re.compile(r"^(Blinds )?\$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) ((?P<LTYPE>NL|PL) )?(?P<GAME>(Hold\'em|Omaha|7 Card Stud))", re.MULTILINE)
-    re_HandInfo    = re.compile(r".*#(?P<HID>[0-9]+)\n.*\nBlinds \$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<DATETIME>\d\d\d\d/\d\d/\d\d - \d\d:\d\d:\d\d)\nTable (?P<TABLE>[- a-zA-Z]+)")
+    re_HandInfo    = re.compile(r".*#(?P<HID>[0-9]+)\n.*\n(Blinds )?\$?(?P<SB>[.0-9]+)/\$?(?P<BB>[.0-9]+) (?P<GAMETYPE>.*) - (?P<DATETIME>\d\d\d\d/\d\d/\d\d - \d\d:\d\d:\d\d)\nTable (?P<TABLE>[- a-zA-Z]+)")
     re_Button      = re.compile(r"^Seat (?P<BUTTON>\d+) is the button", re.MULTILINE)
     re_PlayerInfo  = re.compile(r"^Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\s+(\$ (?P<CASH>[.0-9]+) USD|new player|All-in) \)", re.MULTILINE)
     re_Board       = re.compile(r"\[ (?P<CARDS>.+) \]")
diff --git a/pyfpdb/RegressionTest.py b/pyfpdb/RegressionTest.py
index bfbbdf5a..23e60b0b 100755
--- a/pyfpdb/RegressionTest.py
+++ b/pyfpdb/RegressionTest.py
@@ -133,7 +133,7 @@ Table Jeonju
 Seat 4 is the button
 Total number of players: 5
 """
-        #NLHE 
+        #NLHE
         m = self.everleaf.re_GameInfo.search(cash_nlhe)
         sb = m.group('SB')
         bb = m.group('BB')

From aecb6092d03d9fa7358996f57cad2176b34b1ad5 Mon Sep 17 00:00:00 2001
From: eblade <blade.eric@gmail.com>
Date: Sat, 28 Feb 2009 14:21:59 -0500
Subject: [PATCH 04/15] fix missing self.

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

diff --git a/pyfpdb/Hud.py b/pyfpdb/Hud.py
index 12f66175..da791415 100644
--- a/pyfpdb/Hud.py
+++ b/pyfpdb/Hud.py
@@ -303,7 +303,7 @@ class Hud:
                     
                     if this_stat.hudcolor != "":
                         self.label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.colors['hudfgcolor']))
-                        self.stat_windows[stat_dict[s]['seat']].label[r][c].modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse(this_stat.hudcolor))
+                        self.stat_windows[self.stat_dict[s]['seat']].label[r][c].modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse(this_stat.hudcolor))
                         
                     self.stat_windows[self.stat_dict[s]['seat']].label[r][c].set_text(statstring)
                     if statstring != "xxx": # is there a way to tell if this particular stat window is visible already, or no?

From 3cf8239cc906cd3f56c77518c756cd2240b36219 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Sun, 1 Mar 2009 23:05:21 +0900
Subject: [PATCH 05/15] Fix bug inmporting Everleaf PLO

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

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 79c1f7d6..1f8ecbeb 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -62,7 +62,7 @@ class Everleaf(HandHistoryConverter):
     def readSupportedGames(self):
         return [["ring", "hold", "nl"],
                 ["ring", "hold", "pl"],
-                ["ring", "omaha", "pl"]
+                ["ring", "omahahi", "pl"]
                ]
 
     def determineGameType(self):
@@ -221,7 +221,7 @@ class Everleaf(HandHistoryConverter):
 if __name__ == "__main__":
     c = Configuration.Config()
     if len(sys.argv) ==  1:
-        testfile = "regression-test-files/everleaf/Speed_Kuala_full.txt"
+        testfile = "regression-test-files/everleaf/plo/Naos.txt"
     else:
         testfile = sys.argv[1]
     e = Everleaf(c, testfile)
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index 80591a5f..a1c43ead 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -39,7 +39,7 @@ class Hand:
         self.gametype = gametype
         self.string = string
 
-        if gametype[1] == "hold" or self.gametype[1] == "omaha":
+        if gametype[1] == "hold" or self.gametype[1] == "omahahi":
             self.streetList = ['PREFLOP','FLOP','TURN','RIVER'] # a list of the observed street names in order
         elif self.gametype[1] == "razz" or self.gametype[1] == "stud" or self.gametype[1] == "stud8":
             self.streetList = ['ANTES','THIRD','FOURTH','FIFTH','SIXTH','SEVENTH'] # a list of the observed street names in order
@@ -403,7 +403,7 @@ Map the tuple self.gametype onto the pokerstars string describing it
         return string
 
     def writeHand(self, fh=sys.__stdout__):
-        if self.gametype[1] == "hold" or self.gametype[1] == "omaha":
+        if self.gametype[1] == "hold" or self.gametype[1] == "omahahi":
             self.writeHoldemHand(fh)
         else:
             self.writeStudHand(fh)
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 93e0beb6..3ed2f4c9 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -141,7 +141,7 @@ class HandHistoryConverter:
 
             self.markStreets(hand)
             # Different calls if stud or holdem like
-            if self.gametype[1] == "hold" or self.gametype[1] == "omaha":
+            if self.gametype[1] == "hold" or self.gametype[1] == "omahahi":
                 self.readBlinds(hand)
                 self.readButton(hand)
                 self.readHeroCards(hand) # want to generalise to draw games
@@ -155,7 +155,7 @@ class HandHistoryConverter:
             for street in hand.streetList: # go through them in order
                 print "DEBUG: ", street
                 if hand.streets.group(street) is not None:
-                    if self.gametype[1] == "hold" or self.gametype[1] == "omaha":
+                    if self.gametype[1] == "hold" or self.gametype[1] == "omahahi":
                         self.readCommunityCards(hand, street) # read community cards
                     elif self.gametype[1] == "razz" or self.gametype[1] == "stud" or self.gametype[1] == "stud8":
                         self.readPlayerCards(hand, street)

From d4cc5d418251f803c3b1acf574274a32829d9545 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Mon, 2 Mar 2009 01:52:52 +0900
Subject: [PATCH 06/15] Initial fix for Everlead limit games

Only one entry in the lookup table at the moment, need to collect data
and expand for all known limits
---
 pyfpdb/Hand.py | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index a1c43ead..dff8de9d 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -402,6 +402,15 @@ Map the tuple self.gametype onto the pokerstars string describing it
         
         return string
 
+    def lookupLimitBetSize(self):
+        #Lookup table  for limit games
+        everleaf = { "0.10" : ("0.02", "0.05")
+                    }
+
+        if self.sitename == "Everleaf":
+            return everleaf[self.bb]
+
+
     def writeHand(self, fh=sys.__stdout__):
         if self.gametype[1] == "hold" or self.gametype[1] == "omahahi":
             self.writeHoldemHand(fh)
@@ -424,13 +433,19 @@ Map the tuple self.gametype onto the pokerstars string describing it
 
 
         #May be more than 1 bb posting
+        if self.gametype[2] == "fl":
+            (smallbet, bigbet) = self.lookupLimitBetSize()
+        else:
+            smallbet = self.sb
+            bigbet = self.bb
+
         for a in self.posted:
             if(a[1] == "small blind"):
-                print >>fh, _("%s: posts small blind $%s" %(a[0], self.sb))
+                print >>fh, _("%s: posts small blind $%s" %(a[0], smallbet))
             if(a[1] == "big blind"):
-                print >>fh, _("%s: posts big blind $%s" %(a[0], self.bb))
+                print >>fh, _("%s: posts big blind $%s" %(a[0], bigbet))
             if(a[1] == "both"):
-                print >>fh, _("%s: posts small & big blinds $%.2f" %(a[0], (Decimal(self.sb) + Decimal(self.bb))))
+                print >>fh, _("%s: posts small & big blinds $%.2f" %(a[0], (Decimal(smallbet) + Decimal(bigbet))))
 
         print >>fh, _("*** HOLE CARDS ***")
         if self.involved:

From 3018483a6f04c340564bf9f3229aaf95f505167b Mon Sep 17 00:00:00 2001
From: eblade <blade.eric@gmail.com>
Date: Sun, 1 Mar 2009 15:58:12 -0500
Subject: [PATCH 07/15] changes to lookup list for sb/bb in flhe

---
 pyfpdb/Hand.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index dff8de9d..16549cb0 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -404,11 +404,15 @@ Map the tuple self.gametype onto the pokerstars string describing it
 
     def lookupLimitBetSize(self):
         #Lookup table  for limit games
-        everleaf = { "0.10" : ("0.02", "0.05")
-                    }
-
-        if self.sitename == "Everleaf":
-            return everleaf[self.bb]
+        betlist = {
+            "Everleaf" : {  "0.10" : ("0.02", "0.05"),
+                            "0.20" : ("0.05", "0.10"),
+                            "0.50" : ("0.10", "0.25"),
+                            "1.00" : ("0.25", "0.50")
+                            
+                }
+            }
+        return betlist[self.sitename][self.bb]
 
 
     def writeHand(self, fh=sys.__stdout__):

From 25ae39d7b54c2517bbd3a9b7cc5e13c1de010236 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Tue, 3 Mar 2009 00:10:15 +0900
Subject: [PATCH 08/15] Minor fixups: set->list and FullTilt lookup table

---
 pyfpdb/EverleafToFpdb.py | 1 +
 pyfpdb/FulltiltToFpdb.py | 8 ++++----
 pyfpdb/Hand.py           | 7 ++++++-
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 1f8ecbeb..175b4695 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -62,6 +62,7 @@ class Everleaf(HandHistoryConverter):
     def readSupportedGames(self):
         return [["ring", "hold", "nl"],
                 ["ring", "hold", "pl"],
+                ["ring", "hold", "fl"],
                 ["ring", "omahahi", "pl"]
                ]
 
diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index 2d2e36d1..c03c056b 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -181,7 +181,7 @@ class FullTilt(HandHistoryConverter):
             # "2c, qh" -> set(["2c","qc"])
             # Also works with Omaha hands.
             cards = m.group('CARDS')
-            cards = set(cards.split(' '))
+            cards = cards.split(' ')
             hand.addHoleCards(cards, m.group('PNAME'))
 
     def readPlayerCards(self, hand, street):
@@ -195,7 +195,7 @@ class FullTilt(HandHistoryConverter):
             if player.group('NEWCARD') != None:
                 print cards
                 cards = cards + " " + player.group('NEWCARD')
-            cards = set(cards.split(' '))
+            cards = cards.split(' ')
             hand.addPlayerCards(cards, player.group('PNAME'))
 
     def readAction(self, hand, street):
@@ -218,7 +218,7 @@ class FullTilt(HandHistoryConverter):
     def readShowdownActions(self, hand):
         for shows in self.re_ShowdownAction.finditer(hand.string):
             cards = shows.group('CARDS')
-            cards = set(cards.split(' '))
+            cards = cards.split(' ')
             hand.addShownCards(cards, shows.group('PNAME'))
 
     def readCollectPot(self,hand):
@@ -229,7 +229,7 @@ class FullTilt(HandHistoryConverter):
         for m in self.re_ShownCards.finditer(hand.string):
             if m.group('CARDS') is not None:
                 cards = m.group('CARDS')
-                cards = set(cards.split(' '))
+                cards = cards.split(' ')
                 hand.addShownCards(cards=cards, player=m.group('PNAME'))
 
 
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index 16549cb0..74a12106 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -409,7 +409,12 @@ Map the tuple self.gametype onto the pokerstars string describing it
                             "0.20" : ("0.05", "0.10"),
                             "0.50" : ("0.10", "0.25"),
                             "1.00" : ("0.25", "0.50")
-                            
+                },
+            "FullTilt" : {  "0.10" : ("0.02", "0.05"),
+                            "0.20" : ("0.05", "0.10"),
+                            "1"    : ("0.25", "0.50"),
+                            "2"    : ("0.50", "1"),
+                            "4"    : ("1", "2")
                 }
             }
         return betlist[self.sitename][self.bb]

From 9ebabc79dd96772e3e243dbc5bb25e7a1dee9deb Mon Sep 17 00:00:00 2001
From: eblade <blade.eric@gmail.com>
Date: Mon, 2 Mar 2009 19:51:18 -0500
Subject: [PATCH 09/15] fix my misspelling of the maxseats var

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

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 1f8ecbeb..407772ed 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -107,7 +107,7 @@ class Everleaf(HandHistoryConverter):
             print "DEBUG: re_HandInfo.search failed: '%s'" %(hand.string)
         hand.handid = m.group('HID')
         hand.tablename = m.group('TABLE')
-        hand.max_seats = 6 # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
+        hand.maxseats = 6 # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
 # These work, but the info is already in the Hand class - should be used for tourneys though.
 #		m.group('SB')
 #		m.group('BB')
@@ -128,7 +128,7 @@ class Everleaf(HandHistoryConverter):
             seatnum = int(a.group('SEAT'))
             hand.addPlayer(seatnum, a.group('PNAME'), a.group('CASH'))
             if seatnum > 6:
-                hand.max_seats = 10 # everleaf currently does 2/6/10 games, so if seats > 6 are in use, it must be 10-max.
+                hand.maxseats = 10 # everleaf currently does 2/6/10 games, so if seats > 6 are in use, it must be 10-max.
                 # TODO: implement lookup list by table-name to determine maxes, then fall back to 6 default/10 here, if there's no entry in the list?
             
         

From 86101c522c36afc98b0de8b34891344c9b482ff9 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Tue, 3 Mar 2009 20:32:01 +0900
Subject: [PATCH 10/15] GuiPositionalStats.py

New tab, output cols aren't labelled properly but we appear to have
something sane
---
 pyfpdb/GuiPositionalStats.py | 178 ++++++++
 pyfpdb/fpdb.py               | 798 ++++++++++++++++++-----------------
 2 files changed, 581 insertions(+), 395 deletions(-)
 create mode 100644 pyfpdb/GuiPositionalStats.py

diff --git a/pyfpdb/GuiPositionalStats.py b/pyfpdb/GuiPositionalStats.py
new file mode 100644
index 00000000..e682ecc4
--- /dev/null
+++ b/pyfpdb/GuiPositionalStats.py
@@ -0,0 +1,178 @@
+#!/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 GuiPositionalStats (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
+        print "DEBUG: attempting to fill stats frame"
+        tmp = self.sql.query['playerStatsByPosition']
+
+        result = self.cursor.execute(self.sql.query['getPlayerId'], (self.heroes[self.activesite],))
+        result = self.cursor.fetchall()
+        if not result == ():
+                pid = result[0][0]
+                pid = result[0][0]
+                tmp = tmp.replace("<player_test>", "(" + str(pid) + ")")
+                self.cursor.execute(tmp)
+                result = self.cursor.fetchall()
+                cols = 16
+                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 = ("Game", "Hands", "VPIP", "PFR", "Saw_F", "SawSD", "WtSDwsF", "W$SD", "FlAFq", "TuAFq", "RvAFq", "PoFAFq", "Net($)", "BB/100", "$/hand", "Variance")
+
+                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, yoptions=gtk.SHRINK)
+                    col +=1 
+
+                for row in range(rows-1):
+                    if(row%2 == 0):
+                        bgcolor = "white"
+                    else:
+                        bgcolor = "lightgrey"
+                    for col in range(cols):
+                        eb = gtk.EventBox()
+                        eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(bgcolor))
+                        if result[row][col]:
+                            l = gtk.Label(result[row][col])
+                        else:
+                            l = gtk.Label(' ')
+                        if col == 0:
+                            l.set_alignment(xalign=0.0, yalign=0.5)
+                        else:
+                            l.set_alignment(xalign=1.0, yalign=0.5)
+                        eb.add(l)
+                        self.stats_table.attach(eb, col, col+1, row+1, row+2, yoptions=gtk.SHRINK)
+                        l.show()
+                        eb.show()
+        self.fdb.db.commit()
+    #end def fillStatsFrame(self, vbox):
+
+    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()
+    
+    def __init__(self, db, config, querylist, debug=True):
+        self.debug=debug
+        self.conf=config
+        
+        # create new db connection to avoid conflicts with other threads
+        self.fdb = fpdb_db.fpdb_db()
+        self.fdb.do_connect(self.conf)
+        self.cursor=self.fdb.cursor
+
+        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/fpdb.py b/pyfpdb/fpdb.py
index 32f5f059..f1ff7e1a 100755
--- a/pyfpdb/fpdb.py
+++ b/pyfpdb/fpdb.py
@@ -22,13 +22,13 @@ from optparse import OptionParser
 
 parser = OptionParser()
 parser.add_option("-x", "--errorsToConsole", action="store_true",
-				help="If passed error output will go to the console rather than .")
+                help="If passed error output will go to the console rather than .")
 (options, sys.argv) = parser.parse_args()
 
 if not options.errorsToConsole:
-	print "Note: error output is being diverted to fpdb-error-log.txt and HUD-error.txt. Any major error will be reported there _only_."
-	errorFile = open('fpdb-error-log.txt', 'w', 0)
-	sys.stderr = errorFile
+    print "Note: error output is being diverted to fpdb-error-log.txt and HUD-error.txt. Any major error will be reported there _only_."
+    errorFile = open('fpdb-error-log.txt', 'w', 0)
+    sys.stderr = errorFile
 
 import pygtk
 pygtk.require('2.0')
@@ -38,6 +38,7 @@ import fpdb_db
 import fpdb_simple
 import GuiBulkImport
 import GuiPlayerStats
+import GuiPositionalStats
 import GuiTableViewer
 import GuiAutoImport
 import GuiGraphViewer
@@ -47,419 +48,426 @@ import Configuration
 VERSION = "0.10"
 
 class fpdb:
-	def tab_clicked(self, widget, tab_name):
-		"""called when a tab button is clicked to activate that tab"""
-		#print "start of tab_clicked"
-		self.display_tab(tab_name)
-	#end def tab_clicked
-		
-	def add_and_display_tab(self, new_tab, new_tab_name):
-		"""just calls the component methods"""
-		self.add_tab(new_tab, new_tab_name)
-		self.display_tab(new_tab_name)
-	#end def add_and_display_tab
-	
-	def add_tab(self, new_tab, new_tab_name):
-		"""adds a tab, namely creates the button and displays it and appends all the relevant arrays"""
-		#print "start of add_tab"
-		for i in self.tab_names: #todo: check this is valid
-			if i==new_tab_name:
-				return # we depend on this to not create duplicate tabs, there's no reason to raise an error here?
-#				raise fpdb_simple.FpdbError("duplicate tab_name not permitted")
-		
-		self.tabs.append(new_tab)
-		self.tab_names.append(new_tab_name)
-		
-		new_tab_sel_button=gtk.ToggleButton(new_tab_name)
-		new_tab_sel_button.connect("clicked", self.tab_clicked, new_tab_name)
-		self.tab_box.add(new_tab_sel_button)
-		new_tab_sel_button.show()
-		self.tab_buttons.append(new_tab_sel_button)
-	#end def add_tab
-	
-	def display_tab(self, new_tab_name):
-		"""displays the indicated tab"""
-		#print "start of display_tab, len(self.tab_names):",len(self.tab_names)
-		tab_no=-1
-		#if len(self.tab_names)>1:
-		for i in range(len(self.tab_names)):
-			#print "display_tab, new_tab_name:",new_tab_name,"  self.tab_names[i]:", self.tab_names[i]
-			if (new_tab_name==self.tab_names[i]):
-				tab_no=i
-				#self.tab_buttons[i].set_active(False)
-		#else:
-		#	tab_no=0
-		
-		#current_tab_no=-1
-		for i in range(len(self.tab_names)):
-			if self.current_tab==self.tabs[i]:
-				#self.tab_buttons[i].set_active(False)
-				pass
-		
-		if tab_no==-1:
-			raise fpdb_simple.FpdbError("invalid tab_no")
-		else:
-			self.main_vbox.remove(self.current_tab)
-			#self.current_tab.destroy()
-			self.current_tab=self.tabs[tab_no]
-			self.main_vbox.add(self.current_tab)
-			self.tab_buttons[tab_no].set_active(True)
-			self.current_tab.show()
-	#end def display_tab
-	
-	def delete_event(self, widget, event, data=None):
-		return False
-	#end def delete_event
+    def tab_clicked(self, widget, tab_name):
+        """called when a tab button is clicked to activate that tab"""
+        #print "start of tab_clicked"
+        self.display_tab(tab_name)
+    #end def tab_clicked
 
-	def destroy(self, widget, data=None):
-		self.quit(widget, data)
-	#end def destroy
-	
-	def dia_about(self, widget, data):
-		print "todo: implement dia_about",
-		print " version = %s, requires database version %s" % (VERSION, "118")
-	#end def dia_about
-	
-	def dia_create_del_database(self, widget, data):
-		print "todo: implement dia_create_del_database"
-		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"
-		self.obtain_global_lock()
-	#end def dia_create_del_user
-	
-	def dia_database_stats(self, widget, data):
-		print "todo: implement dia_database_stats"
-		#string=fpdb_db.getDbStats(db, cursor)
-	#end def dia_database_stats
-	
-	def dia_delete_db_parts(self, widget, data):
-		print "todo: implement dia_delete_db_parts"
-		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"
-		self.obtain_global_lock()
-	#end def dia_edit_profile
+    def add_and_display_tab(self, new_tab, new_tab_name):
+        """just calls the component methods"""
+        self.add_tab(new_tab, new_tab_name)
+        self.display_tab(new_tab_name)
+    #end def add_and_display_tab
 
-	def dia_export_db(self, widget, data):
-		print "todo: implement dia_export_db"
-		self.obtain_global_lock()
-	#end def dia_export_db
-	
-	def dia_get_db_root_credentials(self):
-		"""obtains db root credentials from user"""
-		print "todo: implement dia_get_db_root_credentials"
-#		user, pw=None, None
-#		
-#		dialog=gtk.Dialog(title="DB Credentials needed", parent=None, flags=0,
-#				buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,"Connect and recreate",gtk.RESPONSE_OK))
-#		
-#		label_warning1=gtk.Label("Please enter credentials for a database user for "+self.host+" that has permissions to create a database.")
-#		
-#		
-#		label_user=gtk.Label("Username")
-#		dialog.vbox.add(label_user)
-#		label_user.show()
-#		
-#		response=dialog.run()
-#		dialog.destroy()
-#		return (user, pw, response)
-	#end def dia_get_db_root_credentials
-	
-	def dia_import_db(self, widget, data):
-		print "todo: implement dia_import_db"
-		self.obtain_global_lock()
-	#end def dia_import_db
-	
-	def dia_licensing(self, widget, data):
-		print "todo: implement dia_licensing"
-	#end def dia_licensing
-	
-	def dia_load_profile(self, widget, data):
-		"""Dialogue to select a file to load a profile from"""
-		self.obtain_global_lock()
-		chooser = gtk.FileChooserDialog(title="Please select a profile file to load",
-				action=gtk.FILE_CHOOSER_ACTION_OPEN,
-				buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
-		chooser.set_filename(self.profile)
-		
-		response = chooser.run()
-		chooser.destroy()	
-		if response == gtk.RESPONSE_OK:
-			self.load_profile(chooser.get_filename())
-		elif response == gtk.RESPONSE_CANCEL:
-			print 'User cancelled loading profile'
-	#end def dia_load_profile
-	
-	def dia_recreate_tables(self, widget, data):
-		"""Dialogue that asks user to confirm that he wants to delete and recreate the tables"""
-		self.obtain_global_lock()
-		dia_confirm=gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_WARNING,
-				buttons=(gtk.BUTTONS_YES_NO), message_format="Confirm deleting and recreating tables")
-		diastring=("Please confirm that you want to (re-)create the tables. If there already are tables in the database "+self.db.database+" on "+self.db.host+" they will be deleted.")
-		dia_confirm.format_secondary_text(diastring)#todo: make above string with bold for db, host and deleted
+    def add_tab(self, new_tab, new_tab_name):
+        """adds a tab, namely creates the button and displays it and appends all the relevant arrays"""
+        #print "start of add_tab"
+        for i in self.tab_names: #todo: check this is valid
+            if i==new_tab_name:
+                return # we depend on this to not create duplicate tabs, there's no reason to raise an error here?
+#                raise fpdb_simple.FpdbError("duplicate tab_name not permitted")
 
-		response=dia_confirm.run()
-		dia_confirm.destroy()
-		if response == gtk.RESPONSE_YES:
-			self.db.recreate_tables()
-		elif response == gtk.RESPONSE_NO:
-			print 'User cancelled recreating tables'
-	#end def dia_recreate_tables
-	
-	def dia_regression_test(self, widget, data):
-		print "todo: implement dia_regression_test"
-		self.obtain_global_lock()
-	#end def dia_regression_test
-	
-	def dia_save_profile(self, widget, data):
-		print "todo: implement dia_save_profile"
-	#end def dia_save_profile
-	
-	def diaSetupWizard(self, path):
-		print "todo: implement setup wizard"
-		print "setup wizard not implemented - please create the default configuration file:", path	
-		diaSetupWizard = gtk.Dialog(title="Fatal Error - Config File Missing", parent=None, flags=0, buttons=(gtk.STOCK_QUIT,gtk.RESPONSE_OK))
+        self.tabs.append(new_tab)
+        self.tab_names.append(new_tab_name)
 
-		label = gtk.Label("Please copy the config file from the docs folder to:")
-		diaSetupWizard.vbox.add(label)
-		label.show()
-		
-		label = gtk.Label(path)
-		diaSetupWizard.vbox.add(label)
-		label.show()
-		
-		label = gtk.Label("and edit it according to the install documentation at http://fpdb.sourceforge.net")
-		diaSetupWizard.vbox.add(label)
-		label.show()
+        new_tab_sel_button=gtk.ToggleButton(new_tab_name)
+        new_tab_sel_button.connect("clicked", self.tab_clicked, new_tab_name)
+        self.tab_box.add(new_tab_sel_button)
+        new_tab_sel_button.show()
+        self.tab_buttons.append(new_tab_sel_button)
+    #end def add_tab
 
-		response = diaSetupWizard.run()
-		sys.exit(1)
-	#end def diaSetupWizard
-	
-	def get_menu(self, window):
-		"""returns the menu for this program"""
-		accel_group = gtk.AccelGroup()
-		self.item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)
-		self.item_factory.create_items(self.menu_items)
-		window.add_accel_group(accel_group)
-		return self.item_factory.get_widget("<main>")
-	#end def get_menu
-	
-	def load_profile(self):
-		"""Loads profile from the provided path name."""
-		self.settings = {}
-		if (os.sep=="/"):
-			self.settings['os']="linuxmac"
-		else:
-			self.settings['os']="windows"
+    def display_tab(self, new_tab_name):
+        """displays the indicated tab"""
+        #print "start of display_tab, len(self.tab_names):",len(self.tab_names)
+        tab_no=-1
+        #if len(self.tab_names)>1:
+        for i in range(len(self.tab_names)):
+            #print "display_tab, new_tab_name:",new_tab_name,"  self.tab_names[i]:", self.tab_names[i]
+            if (new_tab_name==self.tab_names[i]):
+                tab_no=i
+                #self.tab_buttons[i].set_active(False)
+        #else:
+        #    tab_no=0
 
-		self.settings.update(self.config.get_db_parameters())
-		self.settings.update(self.config.get_tv_parameters())
-		self.settings.update(self.config.get_import_parameters())
-		self.settings.update(self.config.get_default_paths())
-		
-		if self.db!=None:
-			self.db.disconnect()
-		
-		self.db = fpdb_db.fpdb_db()
-		#print "end of fpdb.load_profile, databaseName:",self.settings['db-databaseName']
-		self.db.connect(self.settings['db-backend'],
+        #current_tab_no=-1
+        for i in range(len(self.tab_names)):
+            if self.current_tab==self.tabs[i]:
+                #self.tab_buttons[i].set_active(False)
+                pass
+
+        if tab_no==-1:
+            raise fpdb_simple.FpdbError("invalid tab_no")
+        else:
+            self.main_vbox.remove(self.current_tab)
+            #self.current_tab.destroy()
+            self.current_tab=self.tabs[tab_no]
+            self.main_vbox.add(self.current_tab)
+            self.tab_buttons[tab_no].set_active(True)
+            self.current_tab.show()
+    #end def display_tab
+
+    def delete_event(self, widget, event, data=None):
+        return False
+    #end def delete_event
+
+    def destroy(self, widget, data=None):
+        self.quit(widget, data)
+    #end def destroy
+
+    def dia_about(self, widget, data):
+        print "todo: implement dia_about",
+        print " version = %s, requires database version %s" % (VERSION, "118")
+    #end def dia_about
+
+    def dia_create_del_database(self, widget, data):
+        print "todo: implement dia_create_del_database"
+        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"
+        self.obtain_global_lock()
+    #end def dia_create_del_user
+
+    def dia_database_stats(self, widget, data):
+        print "todo: implement dia_database_stats"
+        #string=fpdb_db.getDbStats(db, cursor)
+    #end def dia_database_stats
+
+    def dia_delete_db_parts(self, widget, data):
+        print "todo: implement dia_delete_db_parts"
+        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"
+        self.obtain_global_lock()
+    #end def dia_edit_profile
+
+    def dia_export_db(self, widget, data):
+        print "todo: implement dia_export_db"
+        self.obtain_global_lock()
+    #end def dia_export_db
+
+    def dia_get_db_root_credentials(self):
+        """obtains db root credentials from user"""
+        print "todo: implement dia_get_db_root_credentials"
+#        user, pw=None, None
+#        
+#        dialog=gtk.Dialog(title="DB Credentials needed", parent=None, flags=0,
+#                buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,"Connect and recreate",gtk.RESPONSE_OK))
+#        
+#        label_warning1=gtk.Label("Please enter credentials for a database user for "+self.host+" that has permissions to create a database.")
+#        
+#        
+#        label_user=gtk.Label("Username")
+#        dialog.vbox.add(label_user)
+#        label_user.show()
+#        
+#        response=dialog.run()
+#        dialog.destroy()
+#        return (user, pw, response)
+    #end def dia_get_db_root_credentials
+
+    def dia_import_db(self, widget, data):
+        print "todo: implement dia_import_db"
+        self.obtain_global_lock()
+    #end def dia_import_db
+
+    def dia_licensing(self, widget, data):
+        print "todo: implement dia_licensing"
+    #end def dia_licensing
+
+    def dia_load_profile(self, widget, data):
+        """Dialogue to select a file to load a profile from"""
+        self.obtain_global_lock()
+        chooser = gtk.FileChooserDialog(title="Please select a profile file to load",
+                action=gtk.FILE_CHOOSER_ACTION_OPEN,
+                buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
+        chooser.set_filename(self.profile)
+
+        response = chooser.run()
+        chooser.destroy()    
+        if response == gtk.RESPONSE_OK:
+            self.load_profile(chooser.get_filename())
+        elif response == gtk.RESPONSE_CANCEL:
+            print 'User cancelled loading profile'
+    #end def dia_load_profile
+
+    def dia_recreate_tables(self, widget, data):
+        """Dialogue that asks user to confirm that he wants to delete and recreate the tables"""
+        self.obtain_global_lock()
+        dia_confirm=gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_WARNING,
+                buttons=(gtk.BUTTONS_YES_NO), message_format="Confirm deleting and recreating tables")
+        diastring=("Please confirm that you want to (re-)create the tables. If there already are tables in the database "+self.db.database+" on "+self.db.host+" they will be deleted.")
+        dia_confirm.format_secondary_text(diastring)#todo: make above string with bold for db, host and deleted
+
+        response=dia_confirm.run()
+        dia_confirm.destroy()
+        if response == gtk.RESPONSE_YES:
+            self.db.recreate_tables()
+        elif response == gtk.RESPONSE_NO:
+            print 'User cancelled recreating tables'
+    #end def dia_recreate_tables
+
+    def dia_regression_test(self, widget, data):
+        print "todo: implement dia_regression_test"
+        self.obtain_global_lock()
+    #end def dia_regression_test
+
+    def dia_save_profile(self, widget, data):
+        print "todo: implement dia_save_profile"
+    #end def dia_save_profile
+
+    def diaSetupWizard(self, path):
+        print "todo: implement setup wizard"
+        print "setup wizard not implemented - please create the default configuration file:", path    
+        diaSetupWizard = gtk.Dialog(title="Fatal Error - Config File Missing", parent=None, flags=0, buttons=(gtk.STOCK_QUIT,gtk.RESPONSE_OK))
+
+        label = gtk.Label("Please copy the config file from the docs folder to:")
+        diaSetupWizard.vbox.add(label)
+        label.show()
+
+        label = gtk.Label(path)
+        diaSetupWizard.vbox.add(label)
+        label.show()
+
+        label = gtk.Label("and edit it according to the install documentation at http://fpdb.sourceforge.net")
+        diaSetupWizard.vbox.add(label)
+        label.show()
+
+        response = diaSetupWizard.run()
+        sys.exit(1)
+    #end def diaSetupWizard
+
+    def get_menu(self, window):
+        """returns the menu for this program"""
+        accel_group = gtk.AccelGroup()
+        self.item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)
+        self.item_factory.create_items(self.menu_items)
+        window.add_accel_group(accel_group)
+        return self.item_factory.get_widget("<main>")
+    #end def get_menu
+
+    def load_profile(self):
+        """Loads profile from the provided path name."""
+        self.settings = {}
+        if (os.sep=="/"):
+            self.settings['os']="linuxmac"
+        else:
+            self.settings['os']="windows"
+
+        self.settings.update(self.config.get_db_parameters())
+        self.settings.update(self.config.get_tv_parameters())
+        self.settings.update(self.config.get_import_parameters())
+        self.settings.update(self.config.get_default_paths())
+
+        if self.db!=None:
+            self.db.disconnect()
+
+        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'])
-		if self.db.wrongDbVersion:
-			diaDbVersionWarning = gtk.Dialog(title="Strong Warning - Invalid database version", parent=None, flags=0, buttons=(gtk.STOCK_OK,gtk.RESPONSE_OK))
+        if self.db.wrongDbVersion:
+            diaDbVersionWarning = gtk.Dialog(title="Strong Warning - Invalid database version", parent=None, flags=0, buttons=(gtk.STOCK_OK,gtk.RESPONSE_OK))
 
-			label = gtk.Label("An invalid DB version or missing tables have been detected.")
-			diaDbVersionWarning.vbox.add(label)
-			label.show()
-		
-			label = gtk.Label("This error is not necessarily fatal but it is strongly recommended that you recreate the tables by using the Database menu.")
-			diaDbVersionWarning.vbox.add(label)
-			label.show()
-		
-			label = gtk.Label("Not doing this will likely lead to misbehaviour including fpdb crashes, corrupt data etc.")
-			diaDbVersionWarning.vbox.add(label)
-			label.show()
+            label = gtk.Label("An invalid DB version or missing tables have been detected.")
+            diaDbVersionWarning.vbox.add(label)
+            label.show()
 
-			response = diaDbVersionWarning.run()
-			diaDbVersionWarning.destroy()
+            label = gtk.Label("This error is not necessarily fatal but it is strongly recommended that you recreate the tables by using the Database menu.")
+            diaDbVersionWarning.vbox.add(label)
+            label.show()
 
-		# Database connected to successfully, load queries to pass on to other classes
-		self.querydict = FpdbSQLQueries.FpdbSQLQueries(self.db.get_backend_name())
-	#end def load_profile
-	
-	def not_implemented(self):
-		print "todo: called unimplemented menu entry (users: pls ignore this)"#remove this once more entries are implemented
-	#end def not_implemented
-	
-	def obtain_global_lock(self):
-		print "todo: implement obtain_global_lock (users: pls ignore this)"
-	#end def obtain_global_lock
-	
-	def quit(self, widget, data):
-		print "Quitting normally"
-		#check if current settings differ from profile, if so offer to save or abort
-		self.db.disconnect()
-		gtk.main_quit()
-	#end def quit_cliecked
-	
-	def release_global_lock(self):
-		print "todo: implement release_global_lock"
-	#end def release_global_lock
-	
-	def tab_abbreviations(self, widget, data):
-		print "todo: implement tab_abbreviations"
-	#end def tab_abbreviations
-	
-	def tab_auto_import(self, widget, data):
-		"""opens the auto import tab"""
-		new_aimp_thread=GuiAutoImport.GuiAutoImport(self.settings, self.config)
-		self.threads.append(new_aimp_thread)
-		aimp_tab=new_aimp_thread.get_vbox()
-		self.add_and_display_tab(aimp_tab, "Auto Import")
-	#end def tab_auto_import
+            label = gtk.Label("Not doing this will likely lead to misbehaviour including fpdb crashes, corrupt data etc.")
+            diaDbVersionWarning.vbox.add(label)
+            label.show()
 
-	def tab_bulk_import(self, widget, data):
-		"""opens a tab for bulk importing"""
-		#print "start of tab_bulk_import"
-		new_import_thread=GuiBulkImport.GuiBulkImport(self.db, self.settings, self.config)
-		self.threads.append(new_import_thread)
-		bulk_tab=new_import_thread.get_vbox()
-		self.add_and_display_tab(bulk_tab, "Bulk Import")
-	#end def tab_bulk_import
+            response = diaDbVersionWarning.run()
+            diaDbVersionWarning.destroy()
 
-	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")
+        # Database connected to successfully, load queries to pass on to other classes
+        self.querydict = FpdbSQLQueries.FpdbSQLQueries(self.db.get_backend_name())
+    #end def load_profile
+
+    def not_implemented(self):
+        print "todo: called unimplemented menu entry (users: pls ignore this)"#remove this once more entries are implemented
+    #end def not_implemented
+
+    def obtain_global_lock(self):
+        print "todo: implement obtain_global_lock (users: pls ignore this)"
+    #end def obtain_global_lock
+
+    def quit(self, widget, data):
+        print "Quitting normally"
+        #check if current settings differ from profile, if so offer to save or abort
+        self.db.disconnect()
+        gtk.main_quit()
+    #end def quit_cliecked
+
+    def release_global_lock(self):
+        print "todo: implement release_global_lock"
+    #end def release_global_lock
+
+    def tab_abbreviations(self, widget, data):
+        print "todo: implement tab_abbreviations"
+    #end def tab_abbreviations
+
+    def tab_auto_import(self, widget, data):
+        """opens the auto import tab"""
+        new_aimp_thread=GuiAutoImport.GuiAutoImport(self.settings, self.config)
+        self.threads.append(new_aimp_thread)
+        aimp_tab=new_aimp_thread.get_vbox()
+        self.add_and_display_tab(aimp_tab, "Auto Import")
+    #end def tab_auto_import
+
+    def tab_bulk_import(self, widget, data):
+        """opens a tab for bulk importing"""
+        #print "start of tab_bulk_import"
+        new_import_thread=GuiBulkImport.GuiBulkImport(self.db, self.settings, self.config)
+        self.threads.append(new_import_thread)
+        bulk_tab=new_import_thread.get_vbox()
+        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_positional_stats(self, widget, data):
+        new_ps_thread=GuiPositionalStats.GuiPositionalStats(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, "Ppositional Stats")
 
 
-	def tab_main_help(self, widget, data):
-		"""Displays a tab with the main fpdb help screen"""
-		#print "start of tab_main_help"
-		mh_tab=gtk.Label("""Welcome to Fpdb!
+    def tab_main_help(self, widget, data):
+        """Displays a tab with the main fpdb help screen"""
+        #print "start of tab_main_help"
+        mh_tab=gtk.Label("""Welcome to Fpdb!
 For documentation please visit our website at http://fpdb.sourceforge.net/ or check the docs directory in the fpdb folder.
 Please note that default.conf is no longer needed nor used, all configuration now happens in HUD_config.xml
 This program is licensed under the AGPL3, see docs"""+os.sep+"agpl-3.0.txt")
-		self.add_and_display_tab(mh_tab, "Help")
-	#end def tab_main_help
-	
-	def tab_table_viewer(self, widget, data):
-		"""opens a table viewer tab"""
-		#print "start of tab_table_viewer"
-		new_tv_thread=GuiTableViewer.GuiTableViewer(self.db, self.settings)
-		self.threads.append(new_tv_thread)
-		tv_tab=new_tv_thread.get_vbox()
-		self.add_and_display_tab(tv_tab, "Table Viewer")
-	#end def tab_table_viewer
+        self.add_and_display_tab(mh_tab, "Help")
+    #end def tab_main_help
 
-	def tabGraphViewer(self, widget, data):
-		"""opens a graph viewer tab"""
-		#print "start of tabGraphViewer"
-		new_gv_thread=GuiGraphViewer.GuiGraphViewer(self.db, self.settings, self.querydict, self.config)
-		self.threads.append(new_gv_thread)
-		gv_tab=new_gv_thread.get_vbox()
-		self.add_and_display_tab(gv_tab, "Graphs")
-	#end def tabGraphViewer
+    def tab_table_viewer(self, widget, data):
+        """opens a table viewer tab"""
+        #print "start of tab_table_viewer"
+        new_tv_thread=GuiTableViewer.GuiTableViewer(self.db, self.settings)
+        self.threads.append(new_tv_thread)
+        tv_tab=new_tv_thread.get_vbox()
+        self.add_and_display_tab(tv_tab, "Table Viewer")
+    #end def tab_table_viewer
 
-	def __init__(self):
-		self.threads=[]
-		self.db=None
-		self.config = Configuration.Config()
-		self.load_profile()
-		
-		self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
-		self.window.connect("delete_event", self.delete_event)
-		self.window.connect("destroy", self.destroy)
-		self.window.set_title("Free Poker DB - v%s or higher" % (VERSION, ))
-		self.window.set_border_width(1)
-		self.window.set_size_request(1020,400)
-		self.window.set_resizable(True)
-		
-		self.menu_items = (
-				( "/_Main",                                 None,         None, 0, "<Branch>" ),
-				( "/Main/_Load Profile (broken)",                    "<control>L", self.dia_load_profile, 0, None ),
-				( "/Main/_Edit Profile (todo)",                    "<control>E", self.dia_edit_profile, 0, None ),
-				( "/Main/_Save Profile (todo)",                    None,         self.dia_save_profile, 0, None ),
-				("/Main/sep1", None, None, 0, "<Separator>" ),
-				("/Main/_Quit", "<control>Q", self.quit, 0, None ),
-				("/_Import",                               None,         None, 0, "<Branch>" ),
-				("/Import/_Bulk Import",  "<control>B", self.tab_bulk_import, 0, None ),
-				("/Import/_Auto Import and HUD", "<control>A", self.tab_auto_import, 0, None ),
-				("/Import/Auto _Rating (todo)",                   "<control>R", self.not_implemented, 0, None ),
-				("/_Viewers", None, None, 0, "<Branch>" ),
-				("/_Viewers/_Auto Import and HUD", "<control>A", self.tab_auto_import, 0, None ),
-				("/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)", 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 ),
-				#( "/Viewers/Tourney Replayer
-				( "/_Database",                             None,         None, 0, "<Branch>" ),
-				( "/Database/Create or Delete _Database (todo)",   None,         self.dia_create_del_database, 0, None ),
-				( "/Database/Create or Delete _User (todo)",       None,         self.dia_create_del_user, 0, None ),
-				( "/Database/Create or Recreate _Tables",   None,         self.dia_recreate_tables, 0, None ),
-				( "/Database/_Statistics (todo)",                  None,         self.dia_database_stats, 0, None ),
-				( "/D_ebugging",                            None,         None, 0, "<Branch>" ),
-				( "/Debugging/_Delete Parts of Database (todo)",   None,         self.dia_delete_db_parts, 0, None ),
-				( "/Debugging/_Export DB (todo)",                  None,         self.dia_export_db, 0, None ),
-				( "/Debugging/_Import DB (todo)",                  None,         self.dia_import_db, 0, None ),
-				( "/Debugging/_Regression test (todo)",            None,         self.dia_regression_test, 0, None ),
-				( "/_Help",                                 None,         None, 0, "<LastBranch>" ),
-				( "/Help/_Main Help",                       "<control>H", self.tab_main_help, 0, None ),
-				( "/Help/_Abbrevations (todo)",                    None,         self.tab_abbreviations, 0, None ),
-				( "/Help/sep1",                             None,         None, 0, "<Separator>" ),
-				( "/Help/A_bout (todo)",                           None,         self.dia_about, 0, None ),
-				( "/Help/_License and Copying (todo)",             None,         self.dia_licensing, 0, None )
-		)
-		
-		self.main_vbox = gtk.VBox(False, 1)
-		self.main_vbox.set_border_width(1)
-		self.window.add(self.main_vbox)
-		self.main_vbox.show()
-		
-		menubar = self.get_menu(self.window)
-		self.main_vbox.pack_start(menubar, False, True, 0)
-		menubar.show()
-		#done menubar
-		
-		self.tabs=[]
-		self.tab_names=[]
-		self.tab_buttons=[]
-		self.tab_box = gtk.HBox(False,1)
-		self.main_vbox.pack_start(self.tab_box, False, True, 0)
-		self.tab_box.show()
-		#done tab bar
-		
-		self.current_tab = gtk.VBox(False,1)
-		self.current_tab.set_border_width(1)
-		self.main_vbox.add(self.current_tab)
-		self.current_tab.show()
-		
-		self.tab_main_help(None, None)
-		
-		self.status_bar = gtk.Label("Status: Connected to "+self.db.get_backend_name()+" database named "+self.db.database+" on host "+self.db.host)
-		self.main_vbox.pack_end(self.status_bar, False, True, 0)
-		self.status_bar.show()
-		
-		self.window.show()
-	#end def __init__
+    def tabGraphViewer(self, widget, data):
+        """opens a graph viewer tab"""
+        #print "start of tabGraphViewer"
+        new_gv_thread=GuiGraphViewer.GuiGraphViewer(self.db, self.settings, self.querydict, self.config)
+        self.threads.append(new_gv_thread)
+        gv_tab=new_gv_thread.get_vbox()
+        self.add_and_display_tab(gv_tab, "Graphs")
+    #end def tabGraphViewer
 
-	def main(self):
-		gtk.main()
-		return 0
-	#end def main
+    def __init__(self):
+        self.threads=[]
+        self.db=None
+        self.config = Configuration.Config()
+        self.load_profile()
+
+        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+        self.window.connect("delete_event", self.delete_event)
+        self.window.connect("destroy", self.destroy)
+        self.window.set_title("Free Poker DB - v%s or higher" % (VERSION, ))
+        self.window.set_border_width(1)
+        self.window.set_size_request(1020,400)
+        self.window.set_resizable(True)
+
+        self.menu_items = (
+                ( "/_Main",                                 None,         None, 0, "<Branch>" ),
+                ( "/Main/_Load Profile (broken)",                    "<control>L", self.dia_load_profile, 0, None ),
+                ( "/Main/_Edit Profile (todo)",                    "<control>E", self.dia_edit_profile, 0, None ),
+                ( "/Main/_Save Profile (todo)",                    None,         self.dia_save_profile, 0, None ),
+                ("/Main/sep1", None, None, 0, "<Separator>" ),
+                ("/Main/_Quit", "<control>Q", self.quit, 0, None ),
+                ("/_Import",                               None,         None, 0, "<Branch>" ),
+                ("/Import/_Bulk Import",  "<control>B", self.tab_bulk_import, 0, None ),
+                ("/Import/_Auto Import and HUD", "<control>A", self.tab_auto_import, 0, None ),
+                ("/Import/Auto _Rating (todo)",                   "<control>R", self.not_implemented, 0, None ),
+                ("/_Viewers", None, None, 0, "<Branch>" ),
+                ("/_Viewers/_Auto Import and HUD", "<control>A", self.tab_auto_import, 0, None ),
+                ("/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)", None, self.tab_player_stats, 0, None ),
+                ("/Viewers/Positional Stats (tabulated view)", None, self.tab_positional_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 ),
+                #( "/Viewers/Tourney Replayer
+                ( "/_Database",                             None,         None, 0, "<Branch>" ),
+                ( "/Database/Create or Delete _Database (todo)",   None,         self.dia_create_del_database, 0, None ),
+                ( "/Database/Create or Delete _User (todo)",       None,         self.dia_create_del_user, 0, None ),
+                ( "/Database/Create or Recreate _Tables",   None,         self.dia_recreate_tables, 0, None ),
+                ( "/Database/_Statistics (todo)",                  None,         self.dia_database_stats, 0, None ),
+                ( "/D_ebugging",                            None,         None, 0, "<Branch>" ),
+                ( "/Debugging/_Delete Parts of Database (todo)",   None,         self.dia_delete_db_parts, 0, None ),
+                ( "/Debugging/_Export DB (todo)",                  None,         self.dia_export_db, 0, None ),
+                ( "/Debugging/_Import DB (todo)",                  None,         self.dia_import_db, 0, None ),
+                ( "/Debugging/_Regression test (todo)",            None,         self.dia_regression_test, 0, None ),
+                ( "/_Help",                                 None,         None, 0, "<LastBranch>" ),
+                ( "/Help/_Main Help",                       "<control>H", self.tab_main_help, 0, None ),
+                ( "/Help/_Abbrevations (todo)",                    None,         self.tab_abbreviations, 0, None ),
+                ( "/Help/sep1",                             None,         None, 0, "<Separator>" ),
+                ( "/Help/A_bout (todo)",                           None,         self.dia_about, 0, None ),
+                ( "/Help/_License and Copying (todo)",             None,         self.dia_licensing, 0, None )
+        )
+
+        self.main_vbox = gtk.VBox(False, 1)
+        self.main_vbox.set_border_width(1)
+        self.window.add(self.main_vbox)
+        self.main_vbox.show()
+
+        menubar = self.get_menu(self.window)
+        self.main_vbox.pack_start(menubar, False, True, 0)
+        menubar.show()
+        #done menubar
+
+        self.tabs=[]
+        self.tab_names=[]
+        self.tab_buttons=[]
+        self.tab_box = gtk.HBox(False,1)
+        self.main_vbox.pack_start(self.tab_box, False, True, 0)
+        self.tab_box.show()
+        #done tab bar
+
+        self.current_tab = gtk.VBox(False,1)
+        self.current_tab.set_border_width(1)
+        self.main_vbox.add(self.current_tab)
+        self.current_tab.show()
+
+        self.tab_main_help(None, None)
+
+        self.status_bar = gtk.Label("Status: Connected to "+self.db.get_backend_name()+" database named "+self.db.database+" on host "+self.db.host)
+        self.main_vbox.pack_end(self.status_bar, False, True, 0)
+        self.status_bar.show()
+
+        self.window.show()
+    #end def __init__
+
+    def main(self):
+        gtk.main()
+        return 0
+    #end def main
 
 if __name__ == "__main__":
-	me = fpdb()
-	me.main()
+    me = fpdb()
+    me.main()

From 81279a0c9e38ab96a498686b5df48f8fbf6eb12a Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Tue, 3 Mar 2009 20:43:16 +0900
Subject: [PATCH 11/15] Fix col align

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

diff --git a/pyfpdb/GuiPositionalStats.py b/pyfpdb/GuiPositionalStats.py
index e682ecc4..2d40a135 100644
--- a/pyfpdb/GuiPositionalStats.py
+++ b/pyfpdb/GuiPositionalStats.py
@@ -61,7 +61,7 @@ class GuiPositionalStats (threading.Thread):
                 vbox.add(self.stats_table)
 
                 # Create header row
-                titles = ("Game", "Hands", "VPIP", "PFR", "Saw_F", "SawSD", "WtSDwsF", "W$SD", "FlAFq", "TuAFq", "RvAFq", "PoFAFq", "Net($)", "BB/100", "$/hand", "Variance")
+                titles = ("Game", "Position", "#", "VPIP", "PFR", "Saw_F", "SawSD", "WtSDwsF", "W$SD", "FlAFq", "TuAFq", "RvAFq", "PoFAFq", "Net($)", "BB/100", "$/hand", "Variance")
 
                 col = 0
                 row = 0

From 4d0968630970c6e5d45b4803c47f58907fb39b75 Mon Sep 17 00:00:00 2001
From: eblade <blade.eric@gmail.com>
Date: Wed, 4 Mar 2009 08:17:23 -0500
Subject: [PATCH 12/15] hud_main window resizes to smallest possible size
 whenever a hud is removed from the list (pls test in nix guys tnx)

---
 pyfpdb/HUD_main.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyfpdb/HUD_main.py b/pyfpdb/HUD_main.py
index 7418cfc8..29368c10 100755
--- a/pyfpdb/HUD_main.py
+++ b/pyfpdb/HUD_main.py
@@ -83,6 +83,7 @@ class HUD_main(object):
         self.hud_dict[table].main_window.destroy()
         self.vb.remove(self.hud_dict[table].tablehudlabel)
         del(self.hud_dict[table])
+        self.main_window.resize(1,1)
 
     def create_HUD(self, new_hand_id, table, table_name, max, poker_game, is_tournament, stat_dict, cards):
         
@@ -93,6 +94,7 @@ class HUD_main(object):
                 newlabel = gtk.Label(table.site + " - " + table_name)
                 self.vb.add(newlabel)
                 newlabel.show()
+                self.main_window.resize_children()
     
                 self.hud_dict[table_name].tablehudlabel = newlabel
                 self.hud_dict[table_name].create(new_hand_id, self.config, stat_dict, cards)

From e8552023dadb84d938579ba362a814ce66726ad3 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Wed, 4 Mar 2009 23:29:13 +0900
Subject: [PATCH 13/15] Whitespace and comment updates from monkeyfutz

---
 pyfpdb/EverleafToFpdb.py | 32 ++++++++++++++------------------
 pyfpdb/FulltiltToFpdb.py |  7 ++++---
 pyfpdb/GuiBulkImport.py  |  2 +-
 pyfpdb/Hand.py           |  5 ++---
 4 files changed, 21 insertions(+), 25 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 175b4695..76c9cadd 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -33,14 +33,13 @@ class Everleaf(HandHistoryConverter):
     re_Button      = re.compile(r"^Seat (?P<BUTTON>\d+) is the button", re.MULTILINE)
     re_PlayerInfo  = re.compile(r"^Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\s+(\$ (?P<CASH>[.0-9]+) USD|new player|All-in) \)", re.MULTILINE)
     re_Board       = re.compile(r"\[ (?P<CARDS>.+) \]")
-        
     
     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", "cp1252")
-        
+
 
         try:
             self.ofile     = os.path.join(self.hhdir, file.split(os.path.sep)[-2]+"-"+os.path.basename(file))
@@ -106,22 +105,19 @@ class Everleaf(HandHistoryConverter):
         m =  self.re_HandInfo.search(hand.string)
         if(m == None):
             print "DEBUG: re_HandInfo.search failed: '%s'" %(hand.string)
-        hand.handid = m.group('HID')
+        hand.handid =  m.group('HID')
         hand.tablename = m.group('TABLE')
-        hand.max_seats = 6 # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
-# These work, but the info is already in the Hand class - should be used for tourneys though.
-#		m.group('SB')
-#		m.group('BB')
-#		m.group('GAMETYPE')
+        hand.maxseats = 6     # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
 
-# Believe Everleaf time is GMT/UTC, no transation necessary
-# Stars format (Nov 10 2008): 2008/11/07 12:38:49 CET [2008/11/07 7:38:49 ET]
-# or                        : 2008/11/07 12:38:49 ET
-# Not getting it in my HH files yet, so using
-# 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)
+        # Believe Everleaf time is GMT/UTC, no transation necessary
+        # Stars format (Nov 10 2008): 2008/11/07 12:38:49 CET [2008/11/07 7:38:49 ET]
+        # or                        : 2008/11/07 12:38:49 ET
+        # Not getting it in my HH files yet, so using
+        # 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 = time.strptime(m.group('DATETIME'), "%Y/%m/%d - %H:%M:%S")
+        return
 
     def readPlayerStacks(self, hand):
         m = self.re_PlayerInfo.finditer(hand.string)
@@ -129,7 +125,7 @@ class Everleaf(HandHistoryConverter):
             seatnum = int(a.group('SEAT'))
             hand.addPlayer(seatnum, a.group('PNAME'), a.group('CASH'))
             if seatnum > 6:
-                hand.max_seats = 10 # everleaf currently does 2/6/10 games, so if seats > 6 are in use, it must be 10-max.
+                hand.maxseats = 10 # everleaf currently does 2/6/10 games, so if seats > 6 are in use, it must be 10-max.
                 # TODO: implement lookup list by table-name to determine maxes, then fall back to 6 default/10 here, if there's no entry in the list?
             
         
@@ -144,7 +140,7 @@ class Everleaf(HandHistoryConverter):
                        r"(\*\* Dealing River \*\*(?P<RIVER> \[ \S\S \].+))?", hand.string,re.DOTALL)
 
         hand.addStreets(m)
-            
+
 
     def readCommunityCards(self, hand, street): # street has been matched by markStreets, so exists in this hand
         #print "DEBUG " + street + ":"
@@ -175,7 +171,7 @@ class Everleaf(HandHistoryConverter):
             hand.involved = False
         else:
             hand.hero = m.group('PNAME')
-            # "2c, qh" -> set(["2c","qc"])
+            # "2c, qh" -> ["2c","qc"]
             # Also works with Omaha hands.
             cards = m.group('CARDS')
             cards = cards.split(', ')
diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index c03c056b..e64e9ced 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -66,6 +66,7 @@ class FullTilt(HandHistoryConverter):
         # Full Tilt Poker Game #10777181585: Table Deerfly (deep 6) - $0.01/$0.02 - Pot Limit Omaha Hi - 2:24:44 ET - 2009/02/22
         # Full Tilt Poker Game #10773265574: Table Butte (6 max) - $0.01/$0.02 - Pot Limit Hold'em - 21:33:46 ET - 2009/02/21
         # Full Tilt Poker Game #9403951181: Table CR - tay - $0.05/$0.10 - No Limit Hold'em - 9:40:20 ET - 2008/12/09
+        # Full Tilt Poker Game #10809877615: Table Danville - $0.50/$1 Ante $0.10 - Limit Razz - 21:47:27 ET - 2009/02/23
         structure = "" # nl, pl, cn, cp, fl
         game      = ""
 
@@ -98,9 +99,9 @@ class FullTilt(HandHistoryConverter):
         hand.tablename = m.group('TABLE')
         hand.starttime = time.strptime(m.group('DATETIME'), "%H:%M:%S ET - %Y/%m/%d")
 # These work, but the info is already in the Hand class - should be used for tourneys though.
-#		m.group('SB')
-#		m.group('BB')
-#		m.group('GAMETYPE')
+#       m.group('SB')
+#       m.group('BB')
+#       m.group('GAMETYPE')
 
 # Stars format (Nov 10 2008): 2008/11/07 12:38:49 CET [2008/11/07 7:38:49 ET]
 # or                        : 2008/11/07 12:38:49 ET
diff --git a/pyfpdb/GuiBulkImport.py b/pyfpdb/GuiBulkImport.py
index d61fa2df..9e5fb30f 100755
--- a/pyfpdb/GuiBulkImport.py
+++ b/pyfpdb/GuiBulkImport.py
@@ -44,7 +44,7 @@ class GuiBulkImport():
         starttime = time()
         if not self.importer.settings['threads'] > 1:
             (stored, dups, partial, errs, ttime) = self.importer.runImport()
-            print 'GuiBulkImport.import_dir done: Stored: %d Duplicates: %d Partial: %d Errors: %d in %s seconds - %d/sec'\
+            print 'GuiBulkImport.import_dir done: Stored: %d \tDuplicates: %d \tPartial: %d \tErrors: %d in %s seconds - %d/sec'\
                  % (stored, dups, partial, errs, ttime, stored / ttime)
         else:
             self.importer.RunImportThreaded()
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index 74a12106..1b2e8cfe 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -485,7 +485,7 @@ Map the tuple self.gametype onto the pokerstars string describing it
         # we probably don't need a showdown section in pseudo stars format for our filtering purposes
         if 'SHOWDOWN' in self.actions:
             print >>fh, _("*** SHOW DOWN ***")
-        #TODO: Complete SHOWDOWN
+            #TODO: Complete SHOWDOWN
 
         # Current PS format has the lines:
         # Uncalled bet ($111.25) returned to s0rrow
@@ -589,7 +589,7 @@ Map the tuple self.gametype onto the pokerstars string describing it
         # we probably don't need a showdown section in pseudo stars format for our filtering purposes
         if 'SHOWDOWN' in self.actions:
             print >>fh, _("*** SHOW DOWN ***")
-#            print >>fh, "DEBUG: what do they show"
+            # TODO: print showdown lines.
 
         # Current PS format has the lines:
         # Uncalled bet ($111.25) returned to s0rrow
@@ -773,4 +773,3 @@ class Pot(object):
             return _("too many pots.. no small blind and walk in bb?. self.pots: %s" %(self.pots))
             # I don't know stars format for a walk in the bb when sb doesn't post.
             # The thing to do here is raise a Hand error like fpdb import does and file it into errors.txt
-            

From 740fe92914065960e00b55229f50a5a65fb2bddb Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Thu, 5 Mar 2009 00:10:08 +0900
Subject: [PATCH 14/15] rename hand.string to hand.handText

Few other minor updates to match monkeyfutz
---
 pyfpdb/EverleafToFpdb.py       | 43 +++++++++++++++++-----------------
 pyfpdb/FulltiltToFpdb.py       | 32 ++++++++++++-------------
 pyfpdb/GuiBulkImport.py        |  2 +-
 pyfpdb/Hand.py                 |  4 ++--
 pyfpdb/HandHistoryConverter.py |  4 ++--
 5 files changed, 42 insertions(+), 43 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 76c9cadd..4b0b4402 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -65,7 +65,7 @@ class Everleaf(HandHistoryConverter):
                 ["ring", "omahahi", "pl"]
                ]
 
-    def determineGameType(self):
+    def determineGameType(self, handText):
         # Cheating with this regex, only support nlhe at the moment
         # Blinds $0.50/$1 PL Omaha - 2008/12/07 - 21:59:48
         # Blinds $0.05/$0.10 NL Hold'em - 2009/02/21 - 11:21:57
@@ -80,7 +80,7 @@ class Everleaf(HandHistoryConverter):
         structure = "" # nl, pl, cn, cp, fl
         game      = ""
 
-        m = self.re_GameInfo.search(self.obs)
+        m = self.re_GameInfo.search(handText)
         if m == None:
             return None
         if m.group('LTYPE') == "NL":
@@ -102,9 +102,9 @@ class Everleaf(HandHistoryConverter):
         return gametype
 
     def readHandInfo(self, hand):
-        m =  self.re_HandInfo.search(hand.string)
+        m = self.re_HandInfo.search(hand.handText)
         if(m == None):
-            print "DEBUG: re_HandInfo.search failed: '%s'" %(hand.string)
+            print "DEBUG: re_HandInfo.search failed: '%s'" %(hand.handText)
         hand.handid =  m.group('HID')
         hand.tablename = m.group('TABLE')
         hand.maxseats = 6     # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
@@ -120,7 +120,7 @@ class Everleaf(HandHistoryConverter):
         return
 
     def readPlayerStacks(self, hand):
-        m = self.re_PlayerInfo.finditer(hand.string)
+        m = self.re_PlayerInfo.finditer(hand.handText)
         for a in m:
             seatnum = int(a.group('SEAT'))
             hand.addPlayer(seatnum, a.group('PNAME'), a.group('CASH'))
@@ -132,12 +132,12 @@ class Everleaf(HandHistoryConverter):
     def markStreets(self, hand):
         # PREFLOP = ** Dealing down cards **
         # This re fails if,  say, river is missing; then we don't get the ** that starts the river.
-        #m = re.search('(\*\* Dealing down cards \*\*\n)(?P<PREFLOP>.*?\n\*\*)?( Dealing Flop \*\* \[ (?P<FLOP1>\S\S), (?P<FLOP2>\S\S), (?P<FLOP3>\S\S) \])?(?P<FLOP>.*?\*\*)?( Dealing Turn \*\* \[ (?P<TURN1>\S\S) \])?(?P<TURN>.*?\*\*)?( Dealing River \*\* \[ (?P<RIVER1>\S\S) \])?(?P<RIVER>.*)', hand.string,re.DOTALL)
+        #m = re.search('(\*\* 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.handText,re.DOTALL)
 
         m =  re.search(r"\*\* Dealing down cards \*\*(?P<PREFLOP>.+(?=\*\* Dealing Flop \*\*)|.+)"
                        r"(\*\* Dealing Flop \*\*(?P<FLOP> \[ \S\S, \S\S, \S\S \].+(?=\*\* Dealing Turn \*\*)|.+))?"
                        r"(\*\* Dealing Turn \*\*(?P<TURN> \[ \S\S \].+(?=\*\* Dealing River \*\*)|.+))?"
-                       r"(\*\* Dealing River \*\*(?P<RIVER> \[ \S\S \].+))?", hand.string,re.DOTALL)
+                       r"(\*\* Dealing River \*\*(?P<RIVER> \[ \S\S \].+))?", hand.handText,re.DOTALL)
 
         hand.addStreets(m)
 
@@ -150,32 +150,31 @@ class Everleaf(HandHistoryConverter):
             hand.setCommunityCards(street, m.group('CARDS').split(', '))
 
     def readBlinds(self, hand):
-        try:
-            m = self.re_PostSB.search(hand.string)
+        m = self.re_PostSB.search(hand.handText)
+        if m is not None:
             hand.addBlind(m.group('PNAME'), 'small blind', m.group('SB'))
-        except Exception, e: # no small blind
-            #print e
+        else:
             hand.addBlind(None, None, None)
-        for a in self.re_PostBB.finditer(hand.string):
+        for a in self.re_PostBB.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'big blind', a.group('BB'))
-        for a in self.re_PostBoth.finditer(hand.string):
+        for a in self.re_PostBoth.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'both', a.group('SBBB'))
 
     def readButton(self, hand):
-        hand.buttonpos = int(self.re_Button.search(hand.string).group('BUTTON'))
+        hand.buttonpos = int(self.re_Button.search(hand.handText).group('BUTTON'))
 
     def readHeroCards(self, hand):
-        m = self.re_HeroCards.search(hand.string)
-        if(m == None):
-            #Not involved in hand
-            hand.involved = False
-        else:
+        m = self.re_HeroCards.search(hand.handText)
+        if m:
             hand.hero = m.group('PNAME')
             # "2c, qh" -> ["2c","qc"]
             # Also works with Omaha hands.
             cards = m.group('CARDS')
             cards = cards.split(', ')
             hand.addHoleCards(cards, m.group('PNAME'))
+        else:
+            #Not involved in hand
+            hand.involved = False
 
     def readAction(self, hand, street):
         m = self.re_Action.finditer(hand.streets.group(street))
@@ -196,18 +195,18 @@ class Everleaf(HandHistoryConverter):
 
     def readShowdownActions(self, hand):
         """Reads lines where holecards are reported in a showdown"""
-        for shows in self.re_ShowdownAction.finditer(hand.string):            
+        for shows in self.re_ShowdownAction.finditer(hand.handText):
             cards = shows.group('CARDS')
             cards = cards.split(', ')
             hand.addShownCards(cards, shows.group('PNAME'))
 
     def readCollectPot(self,hand):
-        for m in self.re_CollectPot.finditer(hand.string):
+        for m in self.re_CollectPot.finditer(hand.handText):
             hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
 
     def readShownCards(self,hand):
         """Reads lines where hole & board cards are mixed to form a hand (summary lines)"""
-        for m in self.re_CollectPot.finditer(hand.string):
+        for m in self.re_CollectPot.finditer(hand.handText):
             if m.group('CARDS') is not None:
                 cards = m.group('CARDS')
                 cards = cards.split(', ')
diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index e64e9ced..cec2fd4a 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -61,7 +61,7 @@ class FullTilt(HandHistoryConverter):
                 ["ring", "omaha", "pl"]
                ]
 
-    def determineGameType(self):
+    def determineGameType(self, handText):
         # Cheating with this regex, only support nlhe at the moment
         # Full Tilt Poker Game #10777181585: Table Deerfly (deep 6) - $0.01/$0.02 - Pot Limit Omaha Hi - 2:24:44 ET - 2009/02/22
         # Full Tilt Poker Game #10773265574: Table Butte (6 max) - $0.01/$0.02 - Pot Limit Hold'em - 21:33:46 ET - 2009/02/21
@@ -71,7 +71,7 @@ class FullTilt(HandHistoryConverter):
         game      = ""
 
 
-        m = self.re_GameInfo.search(self.obs)
+        m = self.re_GameInfo.search(handText)
         if m.group('LTYPE') == "No ":
             structure = "nl"
         elif m.group('LTYPE') == "Pot ":
@@ -93,7 +93,7 @@ class FullTilt(HandHistoryConverter):
         return gametype
 
     def readHandInfo(self, hand):
-        m =  self.re_HandInfo.search(hand.string,re.DOTALL)
+        m =  self.re_HandInfo.search(hand.handText,re.DOTALL)
         #print m.groups()
         hand.handid = m.group('HID')
         hand.tablename = m.group('TABLE')
@@ -114,7 +114,7 @@ class FullTilt(HandHistoryConverter):
 #FIXME:        hand.buttonpos = int(m.group('BUTTON'))
 
     def readPlayerStacks(self, hand):
-        m = self.re_PlayerInfo.finditer(hand.string)
+        m = self.re_PlayerInfo.finditer(hand.handText)
         players = []
         for a in m:
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
@@ -127,14 +127,14 @@ class FullTilt(HandHistoryConverter):
             m =  re.search(r"\*\*\* HOLE CARDS \*\*\*(?P<PREFLOP>.+(?=\*\*\* FLOP \*\*\*)|.+)"
                        r"(\*\*\* FLOP \*\*\*(?P<FLOP> \[\S\S \S\S \S\S\].+(?=\*\*\* TURN \*\*\*)|.+))?"
                        r"(\*\*\* TURN \*\*\* \[\S\S \S\S \S\S] (?P<TURN>\[\S\S\].+(?=\*\*\* RIVER \*\*\*)|.+))?"
-                       r"(\*\*\* RIVER \*\*\* \[\S\S \S\S \S\S \S\S] (?P<RIVER>\[\S\S\].+))?", hand.string,re.DOTALL)
+                       r"(\*\*\* RIVER \*\*\* \[\S\S \S\S \S\S \S\S] (?P<RIVER>\[\S\S\].+))?", hand.handText,re.DOTALL)
         elif self.gametype[1] == "razz":
             m =  re.search(r"(?P<ANTES>.+(?=\*\*\* 3RD STREET \*\*\*)|.+)"
                            r"(\*\*\* 3RD STREET \*\*\*(?P<THIRD>.+(?=\*\*\* 4TH STREET \*\*\*)|.+))?"
                            r"(\*\*\* 4TH STREET \*\*\*(?P<FOURTH>.+(?=\*\*\* 5TH STREET \*\*\*)|.+))?"
                            r"(\*\*\* 5TH STREET \*\*\*(?P<FIFTH>.+(?=\*\*\* 6TH STREET \*\*\*)|.+))?"
                            r"(\*\*\* 6TH STREET \*\*\*(?P<SIXTH>.+(?=\*\*\* 7TH STREET \*\*\*)|.+))?"
-                           r"(\*\*\* 7TH STREET \*\*\*(?P<SEVENTH>.+))?", hand.string,re.DOTALL)
+                           r"(\*\*\* 7TH STREET \*\*\*(?P<SEVENTH>.+))?", hand.handText,re.DOTALL)
         hand.addStreets(m)
 
     def readCommunityCards(self, hand, street): # street has been matched by markStreets, so exists in this hand
@@ -146,18 +146,18 @@ class FullTilt(HandHistoryConverter):
 
     def readBlinds(self, hand):
         try:
-            m = self.re_PostSB.search(hand.string)
+            m = self.re_PostSB.search(hand.handText)
             hand.addBlind(m.group('PNAME'), 'small blind', m.group('SB'))
         except: # no small blind
             hand.addBlind(None, None, None)
-        for a in self.re_PostBB.finditer(hand.string):
+        for a in self.re_PostBB.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'big blind', a.group('BB'))
-        for a in self.re_PostBoth.finditer(hand.string):
+        for a in self.re_PostBoth.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'small & big blinds', a.group('SBBB'))
 
     def readAntes(self, hand):
         print "DEBUG: reading antes"
-        m = self.re_Antes.finditer(hand.string)
+        m = self.re_Antes.finditer(hand.handText)
         for player in m:
             print "DEBUG: hand.addAnte(%s,%s)" %(player.group('PNAME'), player.group('ANTE'))
             hand.addAnte(player.group('PNAME'), player.group('ANTE'))
@@ -165,15 +165,15 @@ class FullTilt(HandHistoryConverter):
     def readBringIn(self, hand):
         print "DEBUG: reading bring in"
 #        print hand.string
-        m = self.re_BringIn.search(hand.string,re.DOTALL)
+        m = self.re_BringIn.search(hand.handText,re.DOTALL)
         print "DEBUG: Player bringing in: %s for %s" %(m.group('PNAME'),  m.group('BRINGIN'))
         hand.addBringIn(m.group('PNAME'),  m.group('BRINGIN'))
 
     def readButton(self, hand):
-        hand.buttonpos = int(self.re_Button.search(hand.string).group('BUTTON'))
+        hand.buttonpos = int(self.re_Button.search(hand.handText).group('BUTTON'))
 
     def readHeroCards(self, hand):
-        m = self.re_HeroCards.search(hand.string)
+        m = self.re_HeroCards.search(hand.handText)
         if(m == None):
             #Not involved in hand
             hand.involved = False
@@ -217,17 +217,17 @@ class FullTilt(HandHistoryConverter):
 
 
     def readShowdownActions(self, hand):
-        for shows in self.re_ShowdownAction.finditer(hand.string):
+        for shows in self.re_ShowdownAction.finditer(hand.handText):
             cards = shows.group('CARDS')
             cards = cards.split(' ')
             hand.addShownCards(cards, shows.group('PNAME'))
 
     def readCollectPot(self,hand):
-        for m in self.re_CollectPot.finditer(hand.string):
+        for m in self.re_CollectPot.finditer(hand.handText):
             hand.addCollectPot(player=m.group('PNAME'),pot=m.group('POT'))
 
     def readShownCards(self,hand):
-        for m in self.re_ShownCards.finditer(hand.string):
+        for m in self.re_ShownCards.finditer(hand.handText):
             if m.group('CARDS') is not None:
                 cards = m.group('CARDS')
                 cards = cards.split(' ')
diff --git a/pyfpdb/GuiBulkImport.py b/pyfpdb/GuiBulkImport.py
index 9e5fb30f..c4f3bbe5 100755
--- a/pyfpdb/GuiBulkImport.py
+++ b/pyfpdb/GuiBulkImport.py
@@ -73,7 +73,7 @@ class GuiBulkImport():
         self.importer.setCallHud(False)
         starttime = time()
         (stored, dups, partial, errs, ttime) = self.importer.runImport()
-        print 'GuiBulkImport.import_dir done: Stored: %d Duplicates: %d Partial: %d Errors: %d in %s seconds - %d/sec'\
+        print 'GuiBulkImport.import_dir done: Stored: %d \tDuplicates: %d \tPartial: %d \tErrors: %d in %s seconds - %d/sec'\
              % (stored, dups, partial, errs, ttime, stored / ttime)
         self.importer.clearFileList()
 
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index 1b2e8cfe..3d6fa7c2 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -34,10 +34,10 @@ class Hand:
 #    def __init__(self, sitename, gametype, sb, bb, string):
 
     UPS = {'a':'A', 't':'T', 'j':'J', 'q':'Q', 'k':'K', 'S':'s', 'C':'c', 'H':'h', 'D':'d'}
-    def __init__(self, sitename, gametype, string):
+    def __init__(self, sitename, gametype, handText):
         self.sitename = sitename
         self.gametype = gametype
-        self.string = string
+        self.handText = handText
 
         if gametype[1] == "hold" or self.gametype[1] == "omahahi":
             self.streetList = ['PREFLOP','FLOP','TURN','RIVER'] # a list of the observed street names in order
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index 3ed2f4c9..b8102c06 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -124,7 +124,7 @@ class HandHistoryConverter:
         self.hands = self.splitFileIntoHands()
         outfile = open(self.ofile, 'w')        
         for hand in self.hands:
-            #print "\nDEBUG: Input:\n"+hand.string
+            #print "\nDEBUG: Input:\n"+hand.handText
             self.readHandInfo(hand)
             
             self.readPlayerStacks(hand)
@@ -272,7 +272,7 @@ class HandHistoryConverter:
         list = self.re_SplitHands.split(self.obs)
         list.pop() #Last entry is empty
         for l in list:
-#			print "'" + l + "'"
+#           print "'" + l + "'"
             hands = hands + [Hand.Hand(self.sitename, self.gametype, l)]
         return hands
 

From 50a1ec1ccfd54c1b551339982bc3d1623f714557 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Thu, 5 Mar 2009 01:46:01 +0900
Subject: [PATCH 15/15] Add logging function from futz

---
 pyfpdb/EverleafToFpdb.py       | 15 +++++++++++++--
 pyfpdb/FulltiltToFpdb.py       | 13 ++++++-------
 pyfpdb/Hand.py                 | 17 +++++++++--------
 pyfpdb/HandHistoryConverter.py |  5 +++--
 4 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/pyfpdb/EverleafToFpdb.py b/pyfpdb/EverleafToFpdb.py
index 4b0b4402..80637445 100755
--- a/pyfpdb/EverleafToFpdb.py
+++ b/pyfpdb/EverleafToFpdb.py
@@ -18,6 +18,7 @@
 ########################################################################
 
 import sys
+import logging
 import Configuration
 from HandHistoryConverter import *
 from time import strftime
@@ -82,6 +83,7 @@ class Everleaf(HandHistoryConverter):
 
         m = self.re_GameInfo.search(handText)
         if m == None:
+            logging.debug("Gametype didn't match")
             return None
         if m.group('LTYPE') == "NL":
             structure = "nl"
@@ -104,7 +106,10 @@ class Everleaf(HandHistoryConverter):
     def readHandInfo(self, hand):
         m = self.re_HandInfo.search(hand.handText)
         if(m == None):
-            print "DEBUG: re_HandInfo.search failed: '%s'" %(hand.handText)
+            logging.info("Didn't match re_HandInfo")
+            logging.info(hand.handtext)
+            return None
+        logging.debug("HID %s, Table %s" % (m.group('HID'),  m.group('TABLE')))
         hand.handid =  m.group('HID')
         hand.tablename = m.group('TABLE')
         hand.maxseats = 6     # assume 6-max unless we have proof it's a larger/smaller game, since everleaf doesn't give seat max info
@@ -154,6 +159,7 @@ class Everleaf(HandHistoryConverter):
         if m is not None:
             hand.addBlind(m.group('PNAME'), 'small blind', m.group('SB'))
         else:
+            logging.debug("No small blind")
             hand.addBlind(None, None, None)
         for a in self.re_PostBB.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'big blind', a.group('BB'))
@@ -177,6 +183,7 @@ class Everleaf(HandHistoryConverter):
             hand.involved = False
 
     def readAction(self, hand, street):
+        logging.debug("readAction (%s)" % street)
         m = self.re_Action.finditer(hand.streets.group(street))
         for action in m:
             if action.group('ATYPE') == ' raises':
@@ -190,14 +197,16 @@ class Everleaf(HandHistoryConverter):
             elif action.group('ATYPE') == ' checks':
                 hand.addCheck( street, action.group('PNAME'))
             else:
-                print "DEBUG: unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),)
+                logging.debug("Unimplemented readAction: %s %s" %(action.group('PNAME'),action.group('ATYPE'),))
 
 
     def readShowdownActions(self, hand):
         """Reads lines where holecards are reported in a showdown"""
+        logging.debug("readShowdownActions")
         for shows in self.re_ShowdownAction.finditer(hand.handText):
             cards = shows.group('CARDS')
             cards = cards.split(', ')
+            logging.debug("readShowdownActions %s %s" %(cards, shows.group('PNAME')))
             hand.addShownCards(cards, shows.group('PNAME'))
 
     def readCollectPot(self,hand):
@@ -210,6 +219,8 @@ class Everleaf(HandHistoryConverter):
             if m.group('CARDS') is not None:
                 cards = m.group('CARDS')
                 cards = cards.split(', ')
+                player = m.group('PNAME')
+                logging.debug("readShownCards %s cards=%s" % (player, cards))
                 hand.addShownCards(cards=None, player=m.group('PNAME'), holeandboard=cards)
 
 
diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index cec2fd4a..0a47f026 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -17,6 +17,7 @@
 ########################################################################
 
 import sys
+import logging
 import Configuration
 from HandHistoryConverter import *
 
@@ -86,7 +87,7 @@ class FullTilt(HandHistoryConverter):
         elif m.group('GAME') == "Razz":
             game = "razz"
 
-        print m.groups()
+        logging.debug("HandInfo: %s", m.groupdict())
 
         gametype = ["ring", game, structure, m.group('SB'), m.group('BB')]
         
@@ -156,17 +157,15 @@ class FullTilt(HandHistoryConverter):
             hand.addBlind(a.group('PNAME'), 'small & big blinds', a.group('SBBB'))
 
     def readAntes(self, hand):
-        print "DEBUG: reading antes"
+        logging.debug("reading antes")
         m = self.re_Antes.finditer(hand.handText)
         for player in m:
-            print "DEBUG: hand.addAnte(%s,%s)" %(player.group('PNAME'), player.group('ANTE'))
+            logging.debug("hand.addAnte(%s,%s)" %(player.group('PNAME'), player.group('ANTE')))
             hand.addAnte(player.group('PNAME'), player.group('ANTE'))
 
     def readBringIn(self, hand):
-        print "DEBUG: reading bring in"
-#        print hand.string
         m = self.re_BringIn.search(hand.handText,re.DOTALL)
-        print "DEBUG: Player bringing in: %s for %s" %(m.group('PNAME'),  m.group('BRINGIN'))
+        logging.debug("Player bringing in: %s for %s" %(m.group('PNAME'),  m.group('BRINGIN')))
         hand.addBringIn(m.group('PNAME'),  m.group('BRINGIN'))
 
     def readButton(self, hand):
@@ -191,7 +190,7 @@ class FullTilt(HandHistoryConverter):
         print "DEBUG: razz/stud readPlayerCards"
         print hand.streets.group(street)
         for player in m:
-            print player.groups()
+            logging.debug(player.groupdict())
             cards = player.group('CARDS')
             if player.group('NEWCARD') != None:
                 print cards
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index 3d6fa7c2..adbdcc11 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -21,6 +21,7 @@ import Hand
 import re
 import sys
 import traceback
+import logging
 import os
 import os.path
 import xml.dom.minidom
@@ -123,14 +124,13 @@ If a player has None chips he won't be added."""
 
     def addStreets(self, match):
         # go through m and initialise actions to empty list for each street.
-        if match is not None:
+        if match:
             self.streets = match
             for street in match.groupdict():
                 if match.group(street) is not None:
                     self.actions[street] = []
-
         else:
-            print "empty markStreets match" # better to raise exception and put process hand in a try block
+            logging.error("markstreets didn't match")
 
     def addHoleCards(self, cards, player):
         """\
@@ -193,6 +193,7 @@ Card ranks will be uppercased
             print "[ERROR] discardHoleCard tried to discard a card %s didn't have" % (player,)
 
     def setCommunityCards(self, street, cards):
+        logging.debug("setCommunityCards %s %s" %(street,  cards))
         self.board[street] = [self.card(c) for c in cards]
 
     def card(self,c):
@@ -216,12 +217,12 @@ Card ranks will be uppercased
         # Player in small blind posts
         #   - this is a bet of 1 sb, as yet uncalled.
         # Player in the big blind posts
-        #   - this is a bet of 1 bb and is the new uncalled
+        #   - this is a call of 1 bb and is the new uncalled
         # 
         # If a player posts a big & small blind
         #   - FIXME: We dont record this for later printing yet
         
-        #print "DEBUG addBlind: %s posts %s, %s" % (player, blindtype, amount)
+        logging.debug("addBlind: %s posts %s, %s" % (player, blindtype, amount))
         if player is not None:
             self.bets['PREFLOP'][player].append(Decimal(amount))
             self.stacks[player] -= Decimal(amount)
@@ -397,10 +398,10 @@ Map the tuple self.gametype onto the pokerstars string describing it
               "cp"  : "Cap Pot Limit"
              }
 
-        print "DEBUG: self.gametype: %s" %(self.gametype)
-        string = "%s %s" %(gs[self.gametype[1]], ls[self.gametype[2]])
+        logging.debug("gametype: %s" %(self.gametype))
+        retstring = "%s %s" %(gs[self.gametype[1]], ls[self.gametype[2]])
         
-        return string
+        return retstring
 
     def lookupLimitBetSize(self):
         #Lookup table  for limit games
diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index b8102c06..7558db48 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -21,6 +21,7 @@ import Hand
 import re
 import sys
 import traceback
+import logging
 import os
 import os.path
 import xml.dom.minidom
@@ -74,9 +75,9 @@ gettext.install('myapplication')
 
 
 class HandHistoryConverter:
-#    eval = PokerEval()
+
     def __init__(self, config, file, sitename):
-        print "HandHistory init called"
+        logging.info("HandHistory init called")
         self.c         = config
         self.sitename  = sitename
         self.obs       = ""             # One big string