From d888b7d463ee19c4d94a4a8c7ca4d0cbfa68f2e9 Mon Sep 17 00:00:00 2001
From: grindi <email-is-hidden>
Date: Sun, 8 Nov 2009 23:09:14 +0300
Subject: [PATCH 01/17] Party hhc: cleand, added getTableTitleRe

---
 pyfpdb/PartyPokerToFpdb.py | 103 +++++++++++++++++--------------------
 1 file changed, 48 insertions(+), 55 deletions(-)

diff --git a/pyfpdb/PartyPokerToFpdb.py b/pyfpdb/PartyPokerToFpdb.py
index 4ed0c965..ba597881 100755
--- a/pyfpdb/PartyPokerToFpdb.py
+++ b/pyfpdb/PartyPokerToFpdb.py
@@ -26,29 +26,21 @@ from HandHistoryConverter import *
 
 # PartyPoker HH Format
 
-class PartyPokerParseError(FpdbParseError):
-    "Usage: raise PartyPokerParseError(<msg>[, hh=<hh>][, hid=<hid>])"
+class FpdbParseError(FpdbParseError):
+    "Usage: raise FpdbParseError(<msg>[, hh=<hh>][, hid=<hid>])"
 
     def __init__(self, msg='', hh=None, hid=None):
-        if hh is not None:
-            msg += "\n\nHand history attached below:\n" + self.wrapHh(hh)
-        return super(PartyPokerParseError, self).__init__(msg, hid=hid)
+        return super(FpdbParseError, self).__init__(msg, hid=hid)
 
     def wrapHh(self, hh):
         return ("%(DELIMETER)s\n%(HH)s\n%(DELIMETER)s") % \
                 {'DELIMETER': '#'*50, 'HH': hh}
 
 class PartyPoker(HandHistoryConverter):
-
-############################################################
-#    Class Variables
-
     sitename = "PartyPoker"
     codepage = "cp1252"
-    siteId = 9 # TODO: automate; it's a class variable so shouldn't hit DB too often
-    filetype = "text" # "text" or "xml". I propose we subclass HHC to HHC_Text and HHC_XML.
-
-
+    siteId = 9 
+    filetype = "text" 
     sym = {'USD': "\$", }
 
     # Static regexes
@@ -86,15 +78,15 @@ class PartyPoker(HandHistoryConverter):
 
     re_HandInfo     = re.compile("""
             ^Table\s+
-            (?P<TTYPE>[a-zA-Z0-9 ]+)\s+
-            (?: \#|\(|)(?P<TABLE>\d+)\)?\s+
-            (?:[^ ]+\s+\#(?P<MTTTABLE>\d+).+)? # table number for mtt
-            \((?P<PLAY>Real|Play)\s+Money\)\s+ # FIXME: check if play money is correct
-            Seat\s+(?P<BUTTON>\d+)\sis\sthe\sbutton
+            (?P<TABLE_TYPE>[^#()]+)\s+          # Regular, Speed, etc
+            (?P<TABLE_ID_WRAPPER>\(|\#| )        # \# means sng, ( - mtt, nothing - cash game
+            (?P<TABLE_ID>\d+)  \)?   \s+        # it's global unique id for this table
+            (?:Table\s+\#(?P<TABLE_NUM>\d+).+)? # table num for mtt tournaments
+            \((?P<PLAY>Real|Play)\s+Money\)\s*  
             """,
-          re.MULTILINE|re.VERBOSE)
+          re.VERBOSE|re.MULTILINE)
 
-#    re_TotalPlayers = re.compile("^Total\s+number\s+of\s+players\s*:\s*(?P<MAXSEATS>\d+)", re.MULTILINE)
+    re_CountedSeats = re.compile("^Total\s+number\s+of\s+players\s*:\s*(?P<COUNTED_SEATS>\d+)", re.MULTILINE)
     re_SplitHands   = re.compile('\x00+')
     re_TailSplitHands   = re.compile('(\x00+)')
     lineSplitter    = '\n'
@@ -131,16 +123,12 @@ class PartyPoker(HandHistoryConverter):
                 'CUR': hand.gametype['currency'] if hand.gametype['currency']!='T$' else ''}
             for key in ('CUR_SYM', 'CUR'):
                 subst[key] = re.escape(subst[key])
-            log.debug("player_re: '%s'" % subst['PLYR'])
-            log.debug("CUR_SYM: '%s'" % subst['CUR_SYM'])
-            log.debug("CUR: '%s'" % subst['CUR'])
             self.re_PostSB = re.compile(
-                r"^%(PLYR)s posts small blind \[%(CUR_SYM)s(?P<SB>[.0-9]+) ?%(CUR)s\]\." %  subst,
+                r"^%(PLYR)s posts small blind \[%(CUR_SYM)s(?P<SB>[,.0-9]+) ?%(CUR)s\]\." %  subst,
                 re.MULTILINE)
             self.re_PostBB = re.compile(
-                r"^%(PLYR)s posts big blind \[%(CUR_SYM)s(?P<BB>[.0-9]+) ?%(CUR)s\]\." %  subst,
+                r"^%(PLYR)s posts big blind \[%(CUR_SYM)s(?P<BB>[.,0-9]+) ?%(CUR)s\]\." %  subst,
                 re.MULTILINE)
-            # NOTE: comma is used as a fraction part delimeter in re below
             self.re_PostDead = re.compile(
                 r"^%(PLYR)s posts big blind \+ dead \[(?P<BBNDEAD>[.,0-9]+) ?%(CUR_SYM)s\]\." %  subst,
                 re.MULTILINE)
@@ -195,8 +183,6 @@ class PartyPoker(HandHistoryConverter):
         gametype dict is:
         {'limitType': xxx, 'base': xxx, 'category': xxx}"""
 
-        log.debug(PartyPokerParseError().wrapHh( handText ))
-
         info = {}
         m = self._getGameType(handText)
         if m is None:
@@ -213,22 +199,16 @@ class PartyPoker(HandHistoryConverter):
 
         for expectedField in ['LIMIT', 'GAME']:
             if mg[expectedField] is None:
-                raise PartyPokerParseError(
-                    "Cannot fetch field '%s'" % expectedField,
-                    hh = handText)
+                raise FpdbParseError( "Cannot fetch field '%s'" % expectedField)
         try:
             info['limitType'] = limits[mg['LIMIT'].strip()]
         except:
-            raise PartyPokerParseError(
-                "Unknown limit '%s'" % mg['LIMIT'],
-                hh = handText)
+            raise FpdbParseError("Unknown limit '%s'" % mg['LIMIT'])
 
         try:
             (info['base'], info['category']) = games[mg['GAME']]
         except:
-            raise PartyPokerParseError(
-                "Unknown game type '%s'" % mg['GAME'],
-                hh = handText)
+            raise FpdbParseError("Unknown game type '%s'" % mg['GAME'])
 
         if 'TOURNO' in mg:
             info['type'] = 'tour'
@@ -251,23 +231,21 @@ class PartyPoker(HandHistoryConverter):
         try:
             info.update(self.re_Hid.search(hand.handText).groupdict())
         except:
-            raise PartyPokerParseError("Cannot read HID for current hand", hh=hand.handText)
+            raise FpdbParseError("Cannot read HID for current hand")
 
         try:
             info.update(self.re_HandInfo.search(hand.handText,re.DOTALL).groupdict())
         except:
-            raise PartyPokerParseError("Cannot read Handinfo for current hand",
-            hh=hand.handText, hid = info['HID'])
+            raise FpdbParseError("Cannot read Handinfo for current hand", hid = info['HID'])
 
         try:
             info.update(self._getGameType(hand.handText).groupdict())
         except:
-            raise PartyPokerParseError("Cannot read GameType for current hand",
-            hh=hand.handText, hid = info['HID'])
+            raise FpdbParseError("Cannot read GameType for current hand", hid = info['HID'])
 
 
-#        m = self.re_TotalPlayers.search(hand.handText)
-#        if m: info.update(m.groupdict())
+        m = self.re_CountedSeats.search(hand.handText)
+        if m: info.update(m.groupdict())
 
 
         # FIXME: it's dirty hack
@@ -294,6 +272,7 @@ class PartyPoker(HandHistoryConverter):
             if key == 'DATETIME':
                 #Saturday, July 25, 07:53:52 EDT 2009
                 #Thursday, July 30, 21:40:41 MSKS 2009
+                #Sunday, October 25, 13:39:07 MSK 2009
                 m2 = re.search("\w+, (?P<M>\w+) (?P<D>\d+), (?P<H>\d+):(?P<MIN>\d+):(?P<S>\d+) (?P<TZ>[A-Z]+) (?P<Y>\d+)", info[key])
                 # we cant use '%B' due to locale problems
                 months = ['January', 'February', 'March', 'April','May', 'June',
@@ -307,21 +286,28 @@ class PartyPoker(HandHistoryConverter):
 
             if key == 'HID':
                 hand.handid = info[key]
-            if key == 'TABLE':
-                hand.tablename = info[key]
-            if key == 'BUTTON':
-                hand.buttonpos = info[key]
             if key == 'TOURNO':
                 hand.tourNo = info[key]
+            if key == 'TABLE_ID_WRAPPER':
+                if info[key] == '#':
+                    # FIXME: there is no such property in Hand class
+                    self.isSNG = True
             if key == 'BUYIN':
                 # FIXME: it's dirty hack T_T
                 # code below assumes that tournament rake is equal to zero
                 cur = info[key][0] if info[key][0] not in '0123456789' else ''
                 hand.buyin = info[key] + '+%s0' % cur
+            if key == 'TABLE_ID':
+                hand.tablename = info[key]
+            if key == 'TABLE_NUM':
+                # FIXME: there is no such property in Hand class
+                hand.table_num = info[key]
+            if key == 'COUNTED_SEATS':
+                hand.counted_seats  = info[key]
             if key == 'LEVEL':
                 hand.level = info[key]
             if key == 'PLAY' and info['PLAY'] != 'Real':
-                # if realy there's no play money hh on party
+                # if realy party doesn's save play money hh
                 hand.gametype['currency'] = 'play'
 
     def readButton(self, hand):
@@ -406,8 +392,6 @@ class PartyPoker(HandHistoryConverter):
             blind = smartMin(hand.bb, playersMap[bigBlindSeat][1])
             hand.addBlind(playersMap[bigBlindSeat][0], 'big blind', blind)
 
-
-
     def readHeroCards(self, hand):
         # we need to grab hero's cards
         for street in ('PREFLOP',):
@@ -418,7 +402,6 @@ class PartyPoker(HandHistoryConverter):
                     newcards = renderCards(found.group('NEWCARDS'))
                     hand.addHoleCards(street, hand.hero, closed=newcards, shown=False, mucked=False, dealt=True)
 
-
     def readAction(self, hand, street):
         m = self.re_Action.finditer(hand.streets[street])
         for action in m:
@@ -453,10 +436,9 @@ class PartyPoker(HandHistoryConverter):
             elif actionType == 'checks':
                 hand.addCheck( street, playerName )
             else:
-                raise PartyPokerParseError(
+                raise FpdbParseError(
                     "Unimplemented readAction: '%s' '%s'" % (playerName,actionType,),
-                    hid = hand.hid, hh = hand.handText )
-
+                    hid = hand.hid, )
 
     def readShowdownActions(self, hand):
         # all action in readShownCards
@@ -475,6 +457,17 @@ class PartyPoker(HandHistoryConverter):
 
                 hand.addShownCards(cards=cards, player=m.group('PNAME'), shown=True, mucked=mucked)
 
+    @staticmethod
+    def getTableTitleRe(type, table_name=None, tournament = None, table_number=None):
+        "Returns string to search in windows titles"
+        if type=="tour":
+            print 'party', 'getTableTitleRe', "%s.+Table\s#%s" % (table_name, table_number)
+            return "%s.+Table\s#%s" % (table_name, table_number)
+        else:
+            print 'party', 'getTableTitleRe', table_number
+            return table_name
+
+
 def ringBlinds(ringLimit):
     "Returns blinds for current limit in cash games"
     ringLimit = float(clearMoneyString(ringLimit))

From 2da6e44a75c803ac45c73a8e23c35e90edddc01c Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Mon, 23 Nov 2009 19:29:56 -0500
Subject: [PATCH 02/17] Changes for improved logging.

---
 pyfpdb/Configuration.py | 63 +++++++++++++++++++++++++++--------------
 1 file changed, 41 insertions(+), 22 deletions(-)

diff --git a/pyfpdb/Configuration.py b/pyfpdb/Configuration.py
index 3f183204..3e3c00a3 100755
--- a/pyfpdb/Configuration.py
+++ b/pyfpdb/Configuration.py
@@ -58,29 +58,29 @@ def get_exec_path():
         return os.path.dirname(sys.path[0])
 
 def get_config(file_name, fallback = True):
-    """Looks in cwd and in self.default_config_path for a config file."""
-    config_path = os.path.join(get_exec_path(), file_name)
-    if os.path.exists(config_path):    # there is a file in the cwd
-        return config_path             # so we use it
-    else: # no file in the cwd, look where it should be in the first place
-        config_path = os.path.join(get_default_config_path(), file_name)
-        if os.path.exists(config_path):
+    """Looks in exec dir and in self.default_config_path for a config file."""
+    config_path = os.path.join(DIR_SELF, file_name) # look in exec dir
+    if os.path.exists(config_path) and os.path.isfile(config_path):
+        return config_path # there is a file in the exec dir so we use it
+    else:
+        config_path = os.path.join(DIR_CONFIG, file_name) # look in config dir
+        if os.path.exists(config_path) and os.path.isfile(config_path):
             return config_path
 
 #    No file found
     if not fallback:
         return False
 
-#    OK, fall back to the .example file, should be in the start dir
-    if os.path.exists(file_name + ".example"):
+#    OK, fall back to the .example file, should be in the exec dir
+    if os.path.exists(os.path.join(DIR_SELF, file_name + ".example")):
         try:
-            shutil.copyfile(file_name + ".example", file_name)
+            shutil.copyfile(os.path.join(DIR_SELF, file_name + ".example"), os.path.join(DIR_CONFIG, file_name))
             print "No %s found, using %s.example.\n" % (file_name, file_name)
-            print "A %s file has been created.  You will probably have to edit it." % file_name
-            sys.stderr.write("No %s found, using %s.example.\n" % (file_name, file_name) )
+            print "A %s file has been created.  You will probably have to edit it." % os.path.join(DIR_CONFIG, file_name)
+            log.error("No %s found, using %s.example.\n" % (file_name, file_name) )
         except:
             print "No %s found, cannot fall back. Exiting.\n" % file_name
-            sys.stderr.write("No %s found, cannot fall back. Exiting.\n" % file_name)
+            log.critical("No %s found, cannot fall back. Exiting.\n" % file_name)
             sys.exit()
     return file_name
 
@@ -90,18 +90,26 @@ def get_logger(file_name, config = "config", fallback = False):
         try:
             logging.config.fileConfig(conf)
             log = logging.getLogger(config)
-            log.debug("%s logger initialised" % config)
             return log
         except:
             pass
 
     log = logging.basicConfig()
     log = logging.getLogger()
-    log.debug("config logger initialised")
+    log.error("basicConfig logger initialised")
     return log
 
-#    find a logging.conf file and set up logging
-log = get_logger("logging.conf")
+def check_dir(path, create = True):
+    """Check if a dir exists, optionally creates if not."""
+    if os.path.exists(path):
+        if os.path.isdir(path):
+            return path
+        else:
+            return False
+    if create:
+        print "creating directory %s" % path
+    else:
+        return False
 
 ########################################################################
 # application wide consts
@@ -109,19 +117,31 @@ log = get_logger("logging.conf")
 APPLICATION_NAME_SHORT = 'fpdb'
 APPLICATION_VERSION = 'xx.xx.xx'
 
-DIR_SELF = os.path.dirname(get_exec_path())
-#TODO: imo no good idea to place 'database' in parent dir
-DIR_DATABASES = os.path.join(os.path.dirname(DIR_SELF), 'database')
+DIR_SELF     = get_exec_path()
+DIR_CONFIG   = check_dir(get_default_config_path())
+DIR_DATABASE = check_dir(os.path.join(DIR_CONFIG, 'database'))
+DIR_LOG      = check_dir(os.path.join(DIR_CONFIG, 'log'))
 
 DATABASE_TYPE_POSTGRESQL = 'postgresql'
 DATABASE_TYPE_SQLITE = 'sqlite'
 DATABASE_TYPE_MYSQL = 'mysql'
+#TODO: should this be a tuple or a dict
 DATABASE_TYPES = (
         DATABASE_TYPE_POSTGRESQL,
         DATABASE_TYPE_SQLITE,
         DATABASE_TYPE_MYSQL,
         )
 
+#    find a logging.conf file and set up logging
+log = get_logger("logging.conf", config = "config")
+log.debug("config logger initialised")
+
+# and then log our consts
+log.info("DIR SELF = %s" % DIR_SELF)
+log.info("DIR CONFIG = %s" % DIR_CONFIG)
+log.info("DIR DATABASE = %s" % DIR_DATABASE)
+log.info("DIR LOG = %s" % DIR_LOG)
+
 ########################################################################
 def string_to_bool(string, default=True):
     """converts a string representation of a boolean value to boolean True or False
@@ -398,8 +418,7 @@ class Config:
         if file is not None: # config file path passed in
             file = os.path.expanduser(file)
             if not os.path.exists(file):
-                print "Configuration file %s not found.  Using defaults." % (file)
-                sys.stderr.write("Configuration file %s not found.  Using defaults." % (file))
+                log.error("Specified configuration file %s not found.  Using defaults." % (file))
                 file = None
 
         if file is None: file = get_config("HUD_config.xml")

From bdc3248597261ba97cc015371f2a974e4c49f407 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Mon, 23 Nov 2009 19:32:19 -0500
Subject: [PATCH 03/17] Changes for new logging scheme.

---
 pyfpdb/Database.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py
index 0314d78d..d2fb5651 100755
--- a/pyfpdb/Database.py
+++ b/pyfpdb/Database.py
@@ -45,7 +45,8 @@ import Card
 import Tourney
 from Exceptions import *
 
-log = Configuration.get_logger("logging.conf")
+log = Configuration.get_logger("logging.conf", config = "db")
+log.debug("db logger initialized.")
 
 class Database:
 
@@ -186,14 +187,13 @@ class Database:
         self.config = c
         self.fdb = fpdb_db.fpdb_db()   # sets self.fdb.db self.fdb.cursor and self.fdb.sql
         self.do_connect(c)
-        
+        print "connection =", self.connection
         if self.backend == self.PGSQL:
             from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT, ISOLATION_LEVEL_READ_COMMITTED, ISOLATION_LEVEL_SERIALIZABLE
             #ISOLATION_LEVEL_AUTOCOMMIT     = 0
             #ISOLATION_LEVEL_READ_COMMITTED = 1 
             #ISOLATION_LEVEL_SERIALIZABLE   = 2
 
-
         # where possible avoid creating new SQL instance by using the global one passed in
         if sql is None:
             self.sql = SQL.Sql(db_server = self.db_server)

From ad91c0a5268fe6dfdd8492d7c5f9cbf1ba70db80 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Mon, 23 Nov 2009 19:34:40 -0500
Subject: [PATCH 04/17] Changes for logging.

---
 pyfpdb/HUD_main.py | 37 ++++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/pyfpdb/HUD_main.py b/pyfpdb/HUD_main.py
index 48a412ee..4b8b2eaa 100755
--- a/pyfpdb/HUD_main.py
+++ b/pyfpdb/HUD_main.py
@@ -36,9 +36,7 @@ import traceback
 (options, sys.argv) = Options.fpdb_options()
 
 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('HUD-error.txt', 'w', 0)
-    sys.stderr = errorFile
+    print "Note: error output is being logged. Any major error will be reported there _only_."
 
 import thread
 import time
@@ -52,6 +50,13 @@ import gobject
 
 #    FreePokerTools modules
 import Configuration
+
+print "start logging"
+log = Configuration.get_logger("logging.conf", config = 'hud')
+log.debug("%s logger initialized." % "dud")
+print "logging started"
+
+
 import Database
 from HandHistoryConverter import getTableTitleRe
 #    get the correct module for the current os
@@ -97,6 +102,7 @@ class HUD_main(object):
 
     def __init__(self, db_name = 'fpdb'):
         self.db_name = db_name
+        self.log = log
         self.config = Configuration.Config(file=options.config, dbname=options.dbname)
         self.hud_dict = {}
         self.hud_params = self.config.get_hud_ui_parameters()
@@ -116,6 +122,7 @@ class HUD_main(object):
         self.main_window.show_all()
 
     def destroy(self, *args):             # call back for terminating the main eventloop
+        self.log.info("Terminating normally.")
         gtk.main_quit()
 
     def kill_hud(self, event, table):
@@ -180,11 +187,11 @@ class HUD_main(object):
 #    function idle_func() to be run by the gui thread, at its leisure.
         def idle_func():
             gtk.gdk.threads_enter()
-#            try: 
-            self.hud_dict[table_name].update(new_hand_id, config)
-            [aw.update_gui(new_hand_id) for aw in self.hud_dict[table_name].aux_windows]
-#            finally:
-            gtk.gdk.threads_leave()
+            try: 
+                self.hud_dict[table_name].update(new_hand_id, config)
+                [aw.update_gui(new_hand_id) for aw in self.hud_dict[table_name].aux_windows]
+            finally:
+                gtk.gdk.threads_leave()
             return False
                 
         gobject.idle_add(idle_func)
@@ -197,7 +204,6 @@ class HUD_main(object):
 #    need their own access to the database, but should open their own
 #    if it is required.
         self.db_connection = Database.Database(self.config)
-        
 #       get hero's screen names and player ids
         self.hero, self.hero_ids = {}, {}
         for site in self.config.get_supported_sites():
@@ -206,10 +212,11 @@ class HUD_main(object):
                 site_id = result[0][0]
                 self.hero[site_id] = self.config.supported_sites[site].screen_name
                 self.hero_ids[site_id] = self.db_connection.get_player_id(self.config, site, self.hero[site_id])
-    
+
         while 1: # wait for a new hand number on stdin
             new_hand_id = sys.stdin.readline()
             new_hand_id = string.rstrip(new_hand_id)
+            self.log.debug("Received hand no %s" % new_hand_id)
             if new_hand_id == "":           # blank line means quit
                 self.destroy()
                 break # this thread is not always killed immediately with gtk.main_quit()
@@ -220,8 +227,7 @@ class HUD_main(object):
                 (table_name, max, poker_game, type, site_id, site_name, tour_number, tab_number) = \
                                 self.db_connection.get_table_info(new_hand_id)
             except Exception, err:
-                print "db error: skipping %s" % new_hand_id 
-                sys.stderr.write("Database error: could not find hand %s.\n" % new_hand_id)
+                self.log.error("db error: skipping %s" % new_hand_id)
                 continue
 
             if type == "tour":   # hand is from a tournament
@@ -262,7 +268,8 @@ class HUD_main(object):
 #        If no client window is found on the screen, complain and continue
                     if type == "tour":
                         table_name = "%s %s" % (tour_number, tab_number)
-                    sys.stderr.write("HUD create: table name "+table_name+" not found, skipping.\n")
+#                    sys.stderr.write("HUD create: table name "+table_name+" not found, skipping.\n")
+                    self.log.error("HUD create: table name %s not found, skipping." % table_name)
                 else:
                     tablewindow.max = max
                     tablewindow.site = site_name
@@ -271,8 +278,8 @@ class HUD_main(object):
 
 if __name__== "__main__":
 
-    sys.stderr.write("HUD_main starting\n")
-    sys.stderr.write("Using db name = %s\n" % (options.dbname))
+    log.info("HUD_main starting")
+    log.info("Using db name = %s" % (options.dbname))
 
 #    start the HUD_main object
     hm = HUD_main(db_name = options.dbname)

From 33ce9576276ec1c2688d6db7988cdf8916de07e2 Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Sat, 23 Jan 2010 13:29:03 +0000
Subject: [PATCH 05/17] add run_fpdb.py file in top dir

---
 run_fpdb.py | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100755 run_fpdb.py

diff --git a/run_fpdb.py b/run_fpdb.py
new file mode 100755
index 00000000..a5c06952
--- /dev/null
+++ b/run_fpdb.py
@@ -0,0 +1,31 @@
+#!/usr/bin/python
+
+#Copyright 2008 Carl Gherardi
+#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 os
+import sys
+
+# sys.path[0] holds the dir run_fpdb.py was in
+sys.path[0] = sys.path[0]+os.sep+"pyfpdb"
+
+import fpdb
+
+
+if __name__ == "__main__":
+    me = fpdb.fpdb()
+    me.main()
+    exit()

From 90ea33c74b004cb770d3c1269e719791a26c18dd Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Mon, 25 Jan 2010 12:04:21 -0500
Subject: [PATCH 06/17] Needs to be executable.

---
 pyfpdb/test_PokerStars.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 pyfpdb/test_PokerStars.py

diff --git a/pyfpdb/test_PokerStars.py b/pyfpdb/test_PokerStars.py
old mode 100644
new mode 100755

From 7d7ba94da13c6680247e2f6fd8f6d2e0abe53237 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Tue, 26 Jan 2010 10:56:07 -0500
Subject: [PATCH 07/17] Fix problem with finding HHs for utf-16 files.

---
 pyfpdb/HandHistoryConverter.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/pyfpdb/HandHistoryConverter.py b/pyfpdb/HandHistoryConverter.py
index c0374143..bec2ebae 100644
--- a/pyfpdb/HandHistoryConverter.py
+++ b/pyfpdb/HandHistoryConverter.py
@@ -440,10 +440,9 @@ or None if we fail to get the info """
                     #print "trying", kodec
                     try:
                         in_fh = codecs.open(self.in_path, 'r', kodec)
-                        in_fh.seek(self.index)
-                        log.debug("Opened in_path: '%s' with %s" % (self.in_path, kodec))
-                        self.obs = in_fh.read()
-                        self.index = in_fh.tell()
+                        whole_file = in_fh.read()
+                        self.obs = whole_file[self.index:]
+                        self.index = len(whole_file)
                         in_fh.close()
                         break
                     except:

From 5c88c6b0ada42cef0d5a496012fbd08c2bca23f5 Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Tue, 26 Jan 2010 21:02:37 +0000
Subject: [PATCH 08/17] put database directory next to HUD_config.xml file

---
 pyfpdb/Configuration.py |  6 ++----
 pyfpdb/fpdb_db.py       | 22 ++++++++++++++++------
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/pyfpdb/Configuration.py b/pyfpdb/Configuration.py
index abd5b016..80ef0277 100755
--- a/pyfpdb/Configuration.py
+++ b/pyfpdb/Configuration.py
@@ -113,10 +113,6 @@ log = get_logger("logging.conf")
 APPLICATION_NAME_SHORT = 'fpdb'
 APPLICATION_VERSION = 'xx.xx.xx'
 
-DIR_SELF = os.path.dirname(get_exec_path())
-#TODO: imo no good idea to place 'database' in parent dir
-DIR_DATABASES = os.path.join(os.path.dirname(DIR_SELF), 'database')
-
 DATABASE_TYPE_POSTGRESQL = 'postgresql'
 DATABASE_TYPE_SQLITE = 'sqlite'
 DATABASE_TYPE_MYSQL = 'mysql'
@@ -429,6 +425,8 @@ class Config:
 
         self.doc = doc
         self.file = file
+        self.dir = os.path.dirname(self.file)
+        self.dir_databases = os.path.join(self.dir, 'database')
         self.supported_sites = {}
         self.supported_games = {}
         self.supported_databases = {}        # databaseName --> Database instance
diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py
index 9f6993b9..514823af 100644
--- a/pyfpdb/fpdb_db.py
+++ b/pyfpdb/fpdb_db.py
@@ -41,6 +41,10 @@ except ImportError:
 import FpdbSQLQueries
 import Configuration
 
+
+DB_VERSION = 118
+
+
 # Variance created as sqlite has a bunch of undefined aggregate functions.
 
 class VARIANCE:
@@ -74,6 +78,7 @@ class fpdb_db:
         if config is None:
             raise FpdbError('Configuration not defined')
 
+        self.config = config
         self.settings = {}
         self.settings['os'] = "linuxmac" if os.name != "nt" else "windows"
 
@@ -95,6 +100,8 @@ class fpdb_db:
         self.user = user
         self.password = password
         self.database = database
+        createTables = False
+        
         if backend == fpdb_db.MYSQL_INNODB:
             import MySQLdb
             if use_pool:
@@ -154,10 +161,12 @@ class fpdb_db:
             else:
                 logging.warning("SQLite won't work well without 'sqlalchemy' installed.")
 
-            if not os.path.isdir(Configuration.DIR_DATABASES) and not database ==  ":memory:":
-                print "Creating directory: '%s'" % (Configuration.DIR_DATABASES)
-                os.mkdir(Configuration.DIR_DATABASES)
-                database = os.path.join(Configuration.DIR_DATABASES, database)
+            if not os.path.isdir(self.config.dir_databases) and not database ==  ":memory:":
+                print "Creating directory: '%s'" % (self.config.dir_databases)
+                logging.info("Creating directory: '%s'" % (self.config.dir_databases))
+                os.mkdir(self.config.dir_databases)
+                database = os.path.join(self.config.dir_databases, database)
+                createTables = True
             self.db = sqlite3.connect(database, detect_types=sqlite3.PARSE_DECLTYPES )
             sqlite3.register_converter("bool", lambda x: bool(int(x)))
             sqlite3.register_adapter(bool, lambda x: "1" if x else "0")
@@ -179,8 +188,9 @@ class fpdb_db:
         try:
             self.cursor.execute("SELECT * FROM Settings")
             settings = self.cursor.fetchone()
-            if settings[0] != 118:
-                print "outdated or too new database version - please recreate tables"
+            if settings[0] != DB_VERSION:
+                logging.error("outdated or too new database version (%s) - please recreate tables"
+                              % (settings[0]))
                 self.wrongDbVersion = True
         except:# _mysql_exceptions.ProgrammingError:
             if database !=  ":memory:": print "failed to read settings table - please recreate tables"

From de2b807c9b5d98d7f71ff2d4fb221dfa1d74676b Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Tue, 26 Jan 2010 21:54:58 +0000
Subject: [PATCH 09/17] refine hud_config handling some more (copies .exmaple
 to proper dir)

---
 pyfpdb/Configuration.py | 20 ++++++++++++--------
 run_fpdb.py             |  5 ++++-
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/pyfpdb/Configuration.py b/pyfpdb/Configuration.py
index 80ef0277..11d38bf4 100755
--- a/pyfpdb/Configuration.py
+++ b/pyfpdb/Configuration.py
@@ -56,8 +56,7 @@ def get_exec_path():
     if hasattr(sys, "frozen"):  # compiled by py2exe
         return os.path.dirname(sys.executable)
     else:
-        pathname = os.path.dirname(sys.argv[0])
-        return os.path.abspath(pathname)
+        return sys.path[0]
 
 def get_config(file_name, fallback = True):
     """Looks in cwd and in self.default_config_path for a config file."""
@@ -78,14 +77,19 @@ def get_config(file_name, fallback = True):
 #    OK, fall back to the .example file, should be in the start dir
     if os.path.exists(file_name + ".example"):
         try:
-            shutil.copyfile(file_name + ".example", file_name)
+            shutil.copyfile(file_name + ".example", config_path)
             print "No %s found, using %s.example.\n" % (file_name, file_name)
-            print "A %s file has been created.  You will probably have to edit it." % file_name
-            sys.stderr.write("No %s found, using %s.example.\n" % (file_name, file_name) )
+            print "Config file has been created at %s.\nYou will probably have to edit it." % config_path
+            sys.stderr.write("No %s found, copying %s.example.\n" % (file_name, file_name) )
+            file_name = config_path
         except:
-            print "No %s found, cannot fall back. Exiting.\n" % file_name
-            sys.stderr.write("No %s found, cannot fall back. Exiting.\n" % file_name)
+            print "Error copying .example file, cannot fall back. Exiting.\n"
+            sys.stderr.write("Error copying .example file, cannot fall back. Exiting.\n")
             sys.exit()
+    else:
+        print "No %s found, cannot fall back. Exiting.\n" % file_name
+        sys.stderr.write("No %s found, cannot fall back. Exiting.\n" % file_name)
+        sys.exit()
     return file_name
 
 def get_logger(file_name, config = "config", fallback = False):
@@ -408,7 +412,7 @@ class Config:
                 sys.stderr.write("Configuration file %s not found.  Using defaults." % (file))
                 file = None
 
-        if file is None: file = get_config("HUD_config.xml")
+        if file is None: file = get_config("HUD_config.xml", True)
 
 #    Parse even if there was no real config file found and we are using the example
 #    If using the example, we'll edit it later
diff --git a/run_fpdb.py b/run_fpdb.py
index a5c06952..24f6a4dd 100755
--- a/run_fpdb.py
+++ b/run_fpdb.py
@@ -19,8 +19,11 @@
 import os
 import sys
 
-# sys.path[0] holds the dir run_fpdb.py was in
+# sys.path[0] holds the directory run_fpdb.py is in
 sys.path[0] = sys.path[0]+os.sep+"pyfpdb"
+os.chdir(sys.path[0])
+#print "sys.path[0] =", sys.path[0], "cwd =", os.getcwd()
+
 
 import fpdb
 

From 47baee65f91fd1a2b6d9ce96052ca8c76b47b395 Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Tue, 26 Jan 2010 22:46:48 +0000
Subject: [PATCH 10/17] add tourneyid to hands table (REQUIRES REIMPORT) and
 fix sqlite db access

---
 pyfpdb/Database.py |  1 +
 pyfpdb/SQL.py      |  6 +++++-
 pyfpdb/fpdb_db.py  | 14 ++++++++------
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py
index 7194b230..c24d13fb 100644
--- a/pyfpdb/Database.py
+++ b/pyfpdb/Database.py
@@ -1286,6 +1286,7 @@ class Database:
                 p['tableName'], 
                 p['gameTypeId'], 
                 p['siteHandNo'], 
+                0, # tourneyId: 0 means not a tourney hand
                 p['handStart'], 
                 datetime.today(), #importtime
                 p['seats'],
diff --git a/pyfpdb/SQL.py b/pyfpdb/SQL.py
index 5913c624..5ff4c8e6 100644
--- a/pyfpdb/SQL.py
+++ b/pyfpdb/SQL.py
@@ -214,6 +214,7 @@ class Sql:
                             id BIGINT UNSIGNED AUTO_INCREMENT NOT NULL, PRIMARY KEY (id),
                             tableName VARCHAR(22) NOT NULL,
                             siteHandNo BIGINT NOT NULL,
+                            tourneyId INT UNSIGNED NOT NULL, 
                             gametypeId SMALLINT UNSIGNED NOT NULL, FOREIGN KEY (gametypeId) REFERENCES Gametypes(id),
                             handStart DATETIME NOT NULL,
                             importTime DATETIME NOT NULL,
@@ -249,6 +250,7 @@ class Sql:
                             id BIGSERIAL, PRIMARY KEY (id),
                             tableName VARCHAR(22) NOT NULL,
                             siteHandNo BIGINT NOT NULL,
+                            tourneyId INT NOT NULL,
                             gametypeId INT NOT NULL, FOREIGN KEY (gametypeId) REFERENCES Gametypes(id),
                             handStart timestamp without time zone NOT NULL,
                             importTime timestamp without time zone NOT NULL,
@@ -283,6 +285,7 @@ class Sql:
                             id INTEGER PRIMARY KEY,
                             tableName TEXT(22) NOT NULL,
                             siteHandNo INT NOT NULL,
+                            tourneyId INT NOT NULL,
                             gametypeId INT NOT NULL,
                             handStart REAL NOT NULL,
                             importTime REAL NOT NULL,
@@ -3437,6 +3440,7 @@ class Sql:
                                             tablename,
                                             gametypeid,
                                             sitehandno,
+                                            tourneyId,
                                             handstart,
                                             importtime,
                                             seats,
@@ -3467,7 +3471,7 @@ class Sql:
                                              VALUES
                                               (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
                                                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
-                                               %s, %s, %s, %s, %s, %s, %s, %s, %s)"""
+                                               %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"""
 
 
         self.query['store_hands_players'] = """INSERT INTO HandsPlayers (
diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py
index 514823af..bdbf430c 100644
--- a/pyfpdb/fpdb_db.py
+++ b/pyfpdb/fpdb_db.py
@@ -154,19 +154,21 @@ class fpdb_db:
                     print msg
                     raise FpdbError(msg)
         elif backend == fpdb_db.SQLITE:
-            logging.info("Connecting to SQLite:%(database)s" % {'database':database})
+            logging.info("Connecting to SQLite: %(database)s" % {'database':database})
             import sqlite3
             if use_pool:
                 sqlite3 = pool.manage(sqlite3, pool_size=1)
             else:
                 logging.warning("SQLite won't work well without 'sqlalchemy' installed.")
 
-            if not os.path.isdir(self.config.dir_databases) and not database ==  ":memory:":
-                print "Creating directory: '%s'" % (self.config.dir_databases)
-                logging.info("Creating directory: '%s'" % (self.config.dir_databases))
-                os.mkdir(self.config.dir_databases)
+            if database != ":memory:":
+                if not os.path.isdir(self.config.dir_databases):
+                    print "Creating directory: '%s'" % (self.config.dir_databases)
+                    logging.info("Creating directory: '%s'" % (self.config.dir_databases))
+                    os.mkdir(self.config.dir_databases)
+                    createTables = True # not needed? just test for no settings table
                 database = os.path.join(self.config.dir_databases, database)
-                createTables = True
+            logging.info("  sqlite db: " + database)
             self.db = sqlite3.connect(database, detect_types=sqlite3.PARSE_DECLTYPES )
             sqlite3.register_converter("bool", lambda x: bool(int(x)))
             sqlite3.register_adapter(bool, lambda x: "1" if x else "0")

From 11bc48e126dd961fe58dece3ebd519d35edf0056 Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Tue, 26 Jan 2010 23:54:04 +0000
Subject: [PATCH 11/17] merge fpdb_db.py into Database.py

---
 pyfpdb/Database.py       | 206 +++++++++++++++++++++++++++++++++----
 pyfpdb/Filters.py        |   8 +-
 pyfpdb/GuiAutoImport.py  |   1 -
 pyfpdb/GuiPlayerStats.py |   1 -
 pyfpdb/Hand.py           |   2 +-
 pyfpdb/SQL.py            |  21 ++++
 pyfpdb/Tourney.py        |   2 +-
 pyfpdb/fpdb.py           |   1 -
 pyfpdb/fpdb_db.py        | 213 ---------------------------------------
 pyfpdb/fpdb_import.py    |   1 -
 10 files changed, 215 insertions(+), 241 deletions(-)

diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py
index c24d13fb..2c649dc4 100644
--- a/pyfpdb/Database.py
+++ b/pyfpdb/Database.py
@@ -39,11 +39,30 @@ import string
 import re
 import Queue
 import codecs
+import logging
+import math
+
 
 #    pyGTK modules
 
+
+#    Other library modules
+try:
+    import sqlalchemy.pool as pool
+    use_pool = True
+except ImportError:
+    logging.info("Not using sqlalchemy connection pool.")
+    use_pool = False
+
+try:
+    from numpy import var
+    use_numpy = True
+except ImportError:
+    logging.info("Not using numpy to define variance in sqlite.")
+    use_numpy = False
+
+
 #    FreePokerTools modules
-import fpdb_db
 import Configuration
 import SQL
 import Card
@@ -54,6 +73,27 @@ from Exceptions import *
 log = Configuration.get_logger("logging.conf")
 encoder = codecs.lookup('utf-8')
 
+
+DB_VERSION = 118
+
+
+# Variance created as sqlite has a bunch of undefined aggregate functions.
+
+class VARIANCE:
+    def __init__(self):
+        self.store = []
+
+    def step(self, value):
+        self.store.append(value)
+
+    def finalize(self):
+        return float(var(self.store))
+
+class sqlitemath:
+    def mod(self, a, b):
+        return a%b
+
+
 class Database:
 
     MYSQL_INNODB = 2
@@ -190,7 +230,22 @@ class Database:
         log.info("Creating Database instance, sql = %s" % sql)
         self.config = c
         self.__connected = False
-        self.fdb = fpdb_db.fpdb_db()   # sets self.fdb.db self.fdb.cursor and self.fdb.sql
+        self.settings = {}
+        self.settings['os'] = "linuxmac" if os.name != "nt" else "windows"
+        db_params = c.get_db_parameters()
+        self.import_options = c.get_import_parameters()
+        self.backend = db_params['db-backend']
+        self.db_server = db_params['db-server']
+        self.database = db_params['db-databaseName']
+        self.host = db_params['db-host']
+
+        # where possible avoid creating new SQL instance by using the global one passed in
+        if sql is None:
+            self.sql = SQL.Sql(db_server = self.db_server)
+        else:
+            self.sql = sql
+
+        # connect to db
         self.do_connect(c)
         
         if self.backend == self.PGSQL:
@@ -200,12 +255,6 @@ class Database:
             #ISOLATION_LEVEL_SERIALIZABLE   = 2
 
 
-        # where possible avoid creating new SQL instance by using the global one passed in
-        if sql is None:
-            self.sql = SQL.Sql(db_server = self.db_server)
-        else:
-            self.sql = sql
-
         if self.backend == self.SQLITE and self.database == ':memory:' and self.wrongDbVersion:
             log.info("sqlite/:memory: - creating")
             self.recreate_tables()
@@ -228,8 +277,6 @@ class Database:
         self.h_date_ndays_ago = 'd000000'  # date N days ago ('d' + YYMMDD) for hero
         self.date_nhands_ago = {}          # dates N hands ago per player - not used yet
 
-        self.cursor = self.fdb.cursor
-
         self.saveActions = False if self.import_options['saveActions'] == False else True
 
         self.connection.rollback()  # make sure any locks taken so far are released
@@ -240,14 +287,20 @@ class Database:
         self.hud_style = style
 
     def do_connect(self, c):
+        if c is None:
+            raise FpdbError('Configuration not defined')
+
+        db = c.get_db_parameters()
         try:
-            self.fdb.do_connect(c)
+            self.connect(backend=db['db-backend'],
+                         host=db['db-host'],
+                         database=db['db-databaseName'],
+                         user=db['db-user'],
+                         password=db['db-password'])
         except:
             # error during connect
             self.__connected = False
             raise
-        self.connection = self.fdb.db
-        self.wrongDbVersion = self.fdb.wrongDbVersion
 
         db_params = c.get_db_parameters()
         self.import_options = c.get_import_parameters()
@@ -257,11 +310,118 @@ class Database:
         self.host = db_params['db-host']
         self.__connected = True
 
+    def connect(self, backend=None, host=None, database=None,
+                user=None, password=None):
+        """Connects a database with the given parameters"""
+        if backend is None:
+            raise FpdbError('Database backend not defined')
+        self.backend = backend
+        self.host = host
+        self.user = user
+        self.password = password
+        self.database = database
+        self.connection = None
+        self.cursor     = None
+        
+        if backend == Database.MYSQL_INNODB:
+            import MySQLdb
+            if use_pool:
+                MySQLdb = pool.manage(MySQLdb, pool_size=5)
+            try:
+                self.connection = MySQLdb.connect(host=host, user=user, passwd=password, db=database, use_unicode=True)
+            #TODO: Add port option
+            except MySQLdb.Error, ex:
+                if ex.args[0] == 1045:
+                    raise FpdbMySQLAccessDenied(ex.args[0], ex.args[1])
+                elif ex.args[0] == 2002 or ex.args[0] == 2003: # 2002 is no unix socket, 2003 is no tcp socket
+                    raise FpdbMySQLNoDatabase(ex.args[0], ex.args[1])
+                else:
+                    print "*** WARNING UNKNOWN MYSQL ERROR", ex
+        elif backend == Database.PGSQL:
+            import psycopg2
+            import psycopg2.extensions
+            if use_pool:
+                psycopg2 = pool.manage(psycopg2, pool_size=5)
+            psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
+            # If DB connection is made over TCP, then the variables
+            # host, user and password are required
+            # For local domain-socket connections, only DB name is
+            # needed, and everything else is in fact undefined and/or
+            # flat out wrong
+            # sqlcoder: This database only connect failed in my windows setup??
+            # Modifed it to try the 4 parameter style if the first connect fails - does this work everywhere?
+            connected = False
+            if self.host == "localhost" or self.host == "127.0.0.1":
+                try:
+                    self.connection = psycopg2.connect(database = database)
+                    connected = True
+                except:
+                    # direct connection failed so try user/pass/... version
+                    pass
+            if not connected:
+                try:
+                    self.connection = psycopg2.connect(host = host,
+                                               user = user,
+                                               password = password,
+                                               database = database)
+                except Exception, ex:
+                    if 'Connection refused' in ex.args[0]:
+                        # meaning eg. db not running
+                        raise FpdbPostgresqlNoDatabase(errmsg = ex.args[0])
+                    elif 'password authentication' in ex.args[0]:
+                        raise FpdbPostgresqlAccessDenied(errmsg = ex.args[0])
+                    else:
+                        msg = ex.args[0]
+                    print msg
+                    raise FpdbError(msg)
+        elif backend == Database.SQLITE:
+            logging.info("Connecting to SQLite: %(database)s" % {'database':database})
+            import sqlite3
+            if use_pool:
+                sqlite3 = pool.manage(sqlite3, pool_size=1)
+            else:
+                logging.warning("SQLite won't work well without 'sqlalchemy' installed.")
+
+            if database != ":memory:":
+                if not os.path.isdir(self.config.dir_databases):
+                    print "Creating directory: '%s'" % (self.config.dir_databases)
+                    logging.info("Creating directory: '%s'" % (self.config.dir_databases))
+                    os.mkdir(self.config.dir_databases)
+                database = os.path.join(self.config.dir_databases, database)
+            logging.info("  sqlite db: " + database)
+            self.connection = sqlite3.connect(database, detect_types=sqlite3.PARSE_DECLTYPES )
+            sqlite3.register_converter("bool", lambda x: bool(int(x)))
+            sqlite3.register_adapter(bool, lambda x: "1" if x else "0")
+            self.connection.create_function("floor", 1, math.floor)
+            tmp = sqlitemath()
+            self.connection.create_function("mod", 2, tmp.mod)
+            if use_numpy:
+                self.connection.create_aggregate("variance", 1, VARIANCE)
+            else:
+                logging.warning("Some database functions will not work without NumPy support")
+        else:
+            raise FpdbError("unrecognised database backend:"+backend)
+
+        self.cursor = self.connection.cursor()
+        self.cursor.execute(self.sql.query['set tx level'])
+        self.wrongDbVersion = False
+        try:
+            self.cursor.execute("SELECT * FROM Settings")
+            settings = self.cursor.fetchone()
+            if settings[0] != DB_VERSION:
+                logging.error("outdated or too new database version (%s) - please recreate tables"
+                              % (settings[0]))
+                self.wrongDbVersion = True
+        except:# _mysql_exceptions.ProgrammingError:
+            if database !=  ":memory:": print "failed to read settings table - please recreate tables"
+            self.wrongDbVersion = True
+    #end def connect
+
     def commit(self):
-        self.fdb.db.commit()
+        self.connection.commit()
 
     def rollback(self):
-        self.fdb.db.rollback()
+        self.connection.rollback()
 
     def connected(self):
         return self.__connected
@@ -274,11 +434,18 @@ class Database:
 
     def disconnect(self, due_to_error=False):
         """Disconnects the DB (rolls back if param is true, otherwise commits"""
-        self.fdb.disconnect(due_to_error)
+        if due_to_error:
+            self.connection.rollback()
+        else:
+            self.connection.commit()
+        self.cursor.close()
+        self.connection.close()
     
     def reconnect(self, due_to_error=False):
         """Reconnects the DB"""
-        self.fdb.reconnect(due_to_error=False)
+        #print "started reconnect"
+        self.disconnect(due_to_error)
+        self.connect(self.backend, self.host, self.database, self.user, self.password)
     
     def get_backend_name(self):
         """Returns the name of the currently used backend"""
@@ -291,6 +458,9 @@ class Database:
         else:
             raise FpdbError("invalid backend")
 
+    def get_db_info(self):
+        return (self.host, self.database, self.user, self.password)
+
     def get_table_name(self, hand_id):
         c = self.connection.cursor()
         c.execute(self.sql.query['get_table_name'], (hand_id, ))
@@ -1267,7 +1437,7 @@ class Database:
         try:
             self.get_cursor().execute(self.sql.query['lockForInsert'])
         except:
-            print "Error during fdb.lock_for_insert:", str(sys.exc_value)
+            print "Error during lock_for_insert:", str(sys.exc_value)
     #end def lock_for_insert
 
 ###########################
diff --git a/pyfpdb/Filters.py b/pyfpdb/Filters.py
index b0da336b..3a331bfd 100644
--- a/pyfpdb/Filters.py
+++ b/pyfpdb/Filters.py
@@ -27,8 +27,8 @@ import gobject
 #import pokereval
 
 import Configuration
-import fpdb_db
-import FpdbSQLQueries
+import Database
+import SQL
 import Charset
 
 class Filters(threading.Thread):
@@ -790,10 +790,10 @@ def main(argv=None):
     config = Configuration.Config()
     db = None
 
-    db = fpdb_db.fpdb_db()
+    db = Database.Database()
     db.do_connect(config)
 
-    qdict = FpdbSQLQueries.FpdbSQLQueries(db.get_backend_name())
+    qdict = SQL.SQL(db.get_backend_name())
 
     i = Filters(db, config, qdict)
     main_window = gtk.Window()
diff --git a/pyfpdb/GuiAutoImport.py b/pyfpdb/GuiAutoImport.py
index 517293ec..f9f1c335 100755
--- a/pyfpdb/GuiAutoImport.py
+++ b/pyfpdb/GuiAutoImport.py
@@ -300,7 +300,6 @@ if __name__== "__main__":
     (options, argv) = parser.parse_args()
 
     config = Configuration.Config()
-#    db = fpdb_db.fpdb_db()
 
     settings = {}
     settings['minPrint'] = options.minPrint
diff --git a/pyfpdb/GuiPlayerStats.py b/pyfpdb/GuiPlayerStats.py
index 7a3213e8..c634538e 100644
--- a/pyfpdb/GuiPlayerStats.py
+++ b/pyfpdb/GuiPlayerStats.py
@@ -27,7 +27,6 @@ from time import time, strftime
 import Card
 import fpdb_import
 import Database
-import fpdb_db
 import Filters
 import Charset
 
diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py
index d2b795e6..3906b00c 100644
--- a/pyfpdb/Hand.py
+++ b/pyfpdb/Hand.py
@@ -205,7 +205,7 @@ dealt   whether they were seen in a 'dealt to' line
     def insert(self, db):
         """ Function to insert Hand into database
 Should not commit, and do minimal selects. Callers may want to cache commits
-db: a connected fpdb_db object"""
+db: a connected Database object"""
 
 
         self.stats.getStats(self)
diff --git a/pyfpdb/SQL.py b/pyfpdb/SQL.py
index 5ff4c8e6..43925c01 100644
--- a/pyfpdb/SQL.py
+++ b/pyfpdb/SQL.py
@@ -58,6 +58,27 @@ class Sql:
         self.query['drop_table'] = """DROP TABLE IF EXISTS """   
 
 
+        ##################################################################
+        # Set transaction isolation level
+        ##################################################################
+
+        if db_server == 'mysql' or db_server == 'postgresql':
+            self.query['set tx level'] = """SET SESSION TRANSACTION
+            ISOLATION LEVEL READ COMMITTED"""
+        elif db_server == 'sqlite':
+            self.query['set tx level'] = """ """
+
+
+        ################################
+        # Select basic info
+        ################################
+
+        self.query['getSiteId'] = """SELECT id from Sites where name = %s"""
+
+        self.query['getGames'] = """SELECT DISTINCT category from Gametypes"""
+        
+        self.query['getLimits'] = """SELECT DISTINCT bigBlind from Gametypes ORDER by bigBlind DESC"""
+
         ################################
         # Create Settings
         ################################
diff --git a/pyfpdb/Tourney.py b/pyfpdb/Tourney.py
index 8f7e59c5..281a6710 100644
--- a/pyfpdb/Tourney.py
+++ b/pyfpdb/Tourney.py
@@ -185,7 +185,7 @@ class Tourney(object):
     def old_insert_from_Hand(self, db):
         """ Function to insert Hand into database
 Should not commit, and do minimal selects. Callers may want to cache commits
-db: a connected fpdb_db object"""
+db: a connected Database object"""
         # TODO:
         # Players - base playerid and siteid tuple
         sqlids = db.getSqlPlayerIDs([p[1] for p in self.players], self.siteId)
diff --git a/pyfpdb/fpdb.py b/pyfpdb/fpdb.py
index bff044d5..5136d56b 100755
--- a/pyfpdb/fpdb.py
+++ b/pyfpdb/fpdb.py
@@ -112,7 +112,6 @@ import GuiGraphViewer
 import GuiSessionViewer
 import SQL
 import Database
-import FpdbSQLQueries
 import Configuration
 import Exceptions
 
diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py
index bdbf430c..2c70dd55 100644
--- a/pyfpdb/fpdb_db.py
+++ b/pyfpdb/fpdb_db.py
@@ -16,219 +16,6 @@
 #In the "official" distribution you can find the license in
 #agpl-3.0.txt in the docs folder of the package.
 
-import os
-import re
-import sys
-import logging
-import math
-from time import time, strftime
-from Exceptions import *
 
-try:
-    import sqlalchemy.pool as pool
-    use_pool = True
-except ImportError:
-    logging.info("Not using sqlalchemy connection pool.")
-    use_pool = False
-
-try:
-    from numpy import var
-    use_numpy = True
-except ImportError:
-    logging.info("Not using numpy to define variance in sqlite.")
-    use_numpy = False
-
-import FpdbSQLQueries
-import Configuration
-
-
-DB_VERSION = 118
-
-
-# Variance created as sqlite has a bunch of undefined aggregate functions.
-
-class VARIANCE:
-    def __init__(self):
-        self.store = []
-
-    def step(self, value):
-        self.store.append(value)
-
-    def finalize(self):
-        return float(var(self.store))
-
-class sqlitemath:
-    def mod(self, a, b):
-        return a%b
-
-class fpdb_db:
-    MYSQL_INNODB = 2
-    PGSQL = 3
-    SQLITE = 4
-
-    def __init__(self):
-        """Simple constructor, doesnt really do anything"""
-        self.db             = None
-        self.cursor         = None
-        self.sql            = {}
-    #end def __init__
-
-    def do_connect(self, config=None):
-        """Connects a database using information in config"""
-        if config is None:
-            raise FpdbError('Configuration not defined')
-
-        self.config = config
-        self.settings = {}
-        self.settings['os'] = "linuxmac" if os.name != "nt" else "windows"
-
-        db = config.get_db_parameters()
-        self.connect(backend=db['db-backend'],
-                     host=db['db-host'],
-                     database=db['db-databaseName'],
-                     user=db['db-user'],
-                     password=db['db-password'])
-    #end def do_connect
-
-    def connect(self, backend=None, host=None, database=None,
-                user=None, password=None):
-        """Connects a database with the given parameters"""
-        if backend is None:
-            raise FpdbError('Database backend not defined')
-        self.backend = backend
-        self.host = host
-        self.user = user
-        self.password = password
-        self.database = database
-        createTables = False
-        
-        if backend == fpdb_db.MYSQL_INNODB:
-            import MySQLdb
-            if use_pool:
-                MySQLdb = pool.manage(MySQLdb, pool_size=5)
-            try:
-                self.db = MySQLdb.connect(host=host, user=user, passwd=password, db=database, use_unicode=True)
-            #TODO: Add port option
-            except MySQLdb.Error, ex:
-                if ex.args[0] == 1045:
-                    raise FpdbMySQLAccessDenied(ex.args[0], ex.args[1])
-                elif ex.args[0] == 2002 or ex.args[0] == 2003: # 2002 is no unix socket, 2003 is no tcp socket
-                    raise FpdbMySQLNoDatabase(ex.args[0], ex.args[1])
-                else:
-                    print "*** WARNING UNKNOWN MYSQL ERROR", ex
-        elif backend == fpdb_db.PGSQL:
-            import psycopg2
-            import psycopg2.extensions
-            if use_pool:
-                psycopg2 = pool.manage(psycopg2, pool_size=5)
-            psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
-            # If DB connection is made over TCP, then the variables
-            # host, user and password are required
-            # For local domain-socket connections, only DB name is
-            # needed, and everything else is in fact undefined and/or
-            # flat out wrong
-            # sqlcoder: This database only connect failed in my windows setup??
-            # Modifed it to try the 4 parameter style if the first connect fails - does this work everywhere?
-            connected = False
-            if self.host == "localhost" or self.host == "127.0.0.1":
-                try:
-                    self.db = psycopg2.connect(database = database)
-                    connected = True
-                except:
-                    # direct connection failed so try user/pass/... version
-                    pass
-            if not connected:
-                try:
-                    self.db = psycopg2.connect(host = host,
-                                               user = user,
-                                               password = password,
-                                               database = database)
-                except Exception, ex:
-                    if 'Connection refused' in ex.args[0]:
-                        # meaning eg. db not running
-                        raise FpdbPostgresqlNoDatabase(errmsg = ex.args[0])
-                    elif 'password authentication' in ex.args[0]:
-                        raise FpdbPostgresqlAccessDenied(errmsg = ex.args[0])
-                    else:
-                        msg = ex.args[0]
-                    print msg
-                    raise FpdbError(msg)
-        elif backend == fpdb_db.SQLITE:
-            logging.info("Connecting to SQLite: %(database)s" % {'database':database})
-            import sqlite3
-            if use_pool:
-                sqlite3 = pool.manage(sqlite3, pool_size=1)
-            else:
-                logging.warning("SQLite won't work well without 'sqlalchemy' installed.")
-
-            if database != ":memory:":
-                if not os.path.isdir(self.config.dir_databases):
-                    print "Creating directory: '%s'" % (self.config.dir_databases)
-                    logging.info("Creating directory: '%s'" % (self.config.dir_databases))
-                    os.mkdir(self.config.dir_databases)
-                    createTables = True # not needed? just test for no settings table
-                database = os.path.join(self.config.dir_databases, database)
-            logging.info("  sqlite db: " + database)
-            self.db = sqlite3.connect(database, detect_types=sqlite3.PARSE_DECLTYPES )
-            sqlite3.register_converter("bool", lambda x: bool(int(x)))
-            sqlite3.register_adapter(bool, lambda x: "1" if x else "0")
-            self.db.create_function("floor", 1, math.floor)
-            tmp = sqlitemath()
-            self.db.create_function("mod", 2, tmp.mod)
-            if use_numpy:
-                self.db.create_aggregate("variance", 1, VARIANCE)
-            else:
-                logging.warning("Some database functions will not work without NumPy support")
-        else:
-            raise FpdbError("unrecognised database backend:"+backend)
-
-        self.cursor = self.db.cursor()
-        # Set up query dictionary as early in the connection process as we can.
-        self.sql = FpdbSQLQueries.FpdbSQLQueries(self.get_backend_name())
-        self.cursor.execute(self.sql.query['set tx level'])
-        self.wrongDbVersion = False
-        try:
-            self.cursor.execute("SELECT * FROM Settings")
-            settings = self.cursor.fetchone()
-            if settings[0] != DB_VERSION:
-                logging.error("outdated or too new database version (%s) - please recreate tables"
-                              % (settings[0]))
-                self.wrongDbVersion = True
-        except:# _mysql_exceptions.ProgrammingError:
-            if database !=  ":memory:": print "failed to read settings table - please recreate tables"
-            self.wrongDbVersion = True
-    #end def connect
-
-    def disconnect(self, due_to_error=False):
-        """Disconnects the DB"""
-        if due_to_error:
-            self.db.rollback()
-        else:
-            self.db.commit()
-        self.cursor.close()
-        self.db.close()
-    #end def disconnect
-
-    def reconnect(self, due_to_error=False):
-        """Reconnects the DB"""
-        #print "started fpdb_db.reconnect"
-        self.disconnect(due_to_error)
-        self.connect(self.backend, self.host, self.database, self.user, self.password)
-
-    def get_backend_name(self):
-        """Returns the name of the currently used backend"""
-        if self.backend==2:
-            return "MySQL InnoDB"
-        elif self.backend==3:
-            return "PostgreSQL"
-        elif self.backend==4:
-            return "SQLite"
-        else:
-            raise FpdbError("invalid backend")
-    #end def get_backend_name
-
-    def get_db_info(self):
-        return (self.host, self.database, self.user, self.password)
-    #end def get_db_info
 
 #end class fpdb_db
diff --git a/pyfpdb/fpdb_import.py b/pyfpdb/fpdb_import.py
index 76705839..fe66fcda 100644
--- a/pyfpdb/fpdb_import.py
+++ b/pyfpdb/fpdb_import.py
@@ -35,7 +35,6 @@ import gtk
 
 #    fpdb/FreePokerTools modules
 
-import fpdb_db
 import Database
 import Configuration
 import Exceptions

From 5a9836862f20dc157f4e53e7580821985d035fb4 Mon Sep 17 00:00:00 2001
From: sqlcoder <sqlcoder@buylow.plus.com>
Date: Wed, 27 Jan 2010 00:48:02 +0000
Subject: [PATCH 12/17] sqlite mods, made sqlite the default in
 HUD_config.xml.example - works (roughly) straight out of the box

---
 pyfpdb/Database.py            | 28 ++++++++++++++++++++++++----
 pyfpdb/HUD_config.xml.example |  4 ++--
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py
index 2c649dc4..ddd810ca 100644
--- a/pyfpdb/Database.py
+++ b/pyfpdb/Database.py
@@ -74,7 +74,7 @@ log = Configuration.get_logger("logging.conf")
 encoder = codecs.lookup('utf-8')
 
 
-DB_VERSION = 118
+DB_VERSION = 119
 
 
 # Variance created as sqlite has a bunch of undefined aggregate functions.
@@ -404,6 +404,10 @@ class Database:
 
         self.cursor = self.connection.cursor()
         self.cursor.execute(self.sql.query['set tx level'])
+        self.check_version(database=database, create=True)
+
+
+    def check_version(self, database, create):
         self.wrongDbVersion = False
         try:
             self.cursor.execute("SELECT * FROM Settings")
@@ -413,8 +417,23 @@ class Database:
                               % (settings[0]))
                 self.wrongDbVersion = True
         except:# _mysql_exceptions.ProgrammingError:
-            if database !=  ":memory:": print "failed to read settings table - please recreate tables"
-            self.wrongDbVersion = True
+            if database !=  ":memory:":
+                if create:
+                    print "Failed to read settings table - recreating tables"
+                    log.info("failed to read settings table - recreating tables")
+                    self.recreate_tables()
+                    self.check_version(database=database, create=False)
+                    if not self.wrongDbVersion:
+                        msg = "Edit your screen_name and hand history path in the supported_sites "\
+                              +"section of the \nPreferences window (Main menu) before trying to import hands"
+                        print "\n%s" % msg
+                        log.warning(msg)
+                else:
+                    print "Failed to read settings table - please recreate tables"
+                    log.info("failed to read settings table - please recreate tables")
+                    self.wrongDbVersion = True
+            else:
+                self.wrongDbVersion = True
     #end def connect
 
     def commit(self):
@@ -1016,6 +1035,7 @@ class Database:
         self.create_tables()
         self.createAllIndexes()
         self.commit()
+        print "Finished recreating tables"
         log.info("Finished recreating tables")
     #end def recreate_tables
 
@@ -1281,7 +1301,7 @@ class Database:
     
     def fillDefaultData(self):
         c = self.get_cursor() 
-        c.execute("INSERT INTO Settings (version) VALUES (118);")
+        c.execute("INSERT INTO Settings (version) VALUES (%s);" % (DB_VERSION))
         c.execute("INSERT INTO Sites (name,currency) VALUES ('Full Tilt Poker', 'USD')")
         c.execute("INSERT INTO Sites (name,currency) VALUES ('PokerStars', 'USD')")
         c.execute("INSERT INTO Sites (name,currency) VALUES ('Everleaf', 'USD')")
diff --git a/pyfpdb/HUD_config.xml.example b/pyfpdb/HUD_config.xml.example
index 3acfd812..8b53e609 100644
--- a/pyfpdb/HUD_config.xml.example
+++ b/pyfpdb/HUD_config.xml.example
@@ -588,8 +588,8 @@ Left-Drag to Move"
     </hhcs>
 
     <supported_databases>
-        <database db_name="fpdb" db_server="mysql" db_ip="localhost" db_user="fpdb" db_pass="YOUR MYSQL PASSWORD"></database>
-        <!-- <database db_ip="localhost" db_name="fpdb" db_pass="fpdb" db_server="sqlite" db_user="fpdb"/> -->
+        <!-- <database db_name="fpdb" db_server="mysql" db_ip="localhost" db_user="fpdb" db_pass="YOUR MYSQL PASSWORD"></database> -->
+        <database db_ip="localhost" db_server="sqlite" db_name="fpdb.db3" db_user="fpdb" db_pass="fpdb"/>
     </supported_databases>
 
 </FreePokerToolsConfig>

From 30de5142dba66468236c09eb2079ba7a099d2800 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Wed, 27 Jan 2010 00:57:58 -0500
Subject: [PATCH 13/17] Ugly fix to ugly edge case where winner voluntarily
 showed cards.

---
 pyfpdb/FulltiltToFpdb.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index 1721236a..44b6890e 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -268,7 +268,8 @@ class Fulltilt(HandHistoryConverter):
 
         players = []
         for a in m:
-            hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
+            if not re.search(" collected", a.group('PNAME')):
+                hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
         # PREFLOP = ** Dealing down cards **

From d75e5e39208f13877ebeda46000d3fb6d4088236 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Wed, 27 Jan 2010 01:10:58 -0500
Subject: [PATCH 14/17] Fixed typos, pylint complaints, and obsolete TODOs.

---
 pyfpdb/FulltiltToFpdb.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index 44b6890e..eeefbf90 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -18,12 +18,10 @@
 #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 ########################################################################
 
-import sys
 import logging
 from HandHistoryConverter import *
 
 # Fulltilt HH Format converter
-# TODO: cat tourno and table to make table name for tournaments
 
 class Fulltilt(HandHistoryConverter):
     
@@ -191,7 +189,6 @@ class Fulltilt(HandHistoryConverter):
         if mg['TOURNO'] is None:  info['type'] = "ring"
         else:                     info['type'] = "tour"
         # NB: SB, BB must be interpreted as blinds or bets depending on limit type.
-#        if info['type'] == "tour": return None # importer is screwed on tournies, pass on those hands so we don't interrupt other autoimporting
         return info
 
     def readHandInfo(self, hand):
@@ -266,7 +263,6 @@ class Fulltilt(HandHistoryConverter):
         else:   #if hand.gametype['type'] == "tour"
             m = self.re_TourneyPlayerInfo.finditer(hand.handText)
 
-        players = []
         for a in m:
             if not re.search(" collected", a.group('PNAME')):
                 hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
@@ -423,7 +419,6 @@ class Fulltilt(HandHistoryConverter):
             hand.mixed = self.mixes[m.groupdict()['MIXED']]
 
     def readSummaryInfo(self, summaryInfoList):
-        starttime = time.time()
         self.status = True
 
         m = re.search("Tournament Summary", summaryInfoList[0])
@@ -543,14 +538,14 @@ class Fulltilt(HandHistoryConverter):
                         tourney.buyin = 100*Decimal(re.sub(u',', u'', "%s" % mg['BUYIN']))
                     else :
                         if 100*Decimal(re.sub(u',', u'', "%s" % mg['BUYIN'])) != tourney.buyin:
-                            log.error( "Conflict between buyins read in topline (%s) and in BuyIn field (%s)" % (touney.buyin, 100*Decimal(re.sub(u',', u'', "%s" % mg['BUYIN']))) )
+                            log.error( "Conflict between buyins read in topline (%s) and in BuyIn field (%s)" % (tourney.buyin, 100*Decimal(re.sub(u',', u'', "%s" % mg['BUYIN']))) )
                             tourney.subTourneyBuyin = 100*Decimal(re.sub(u',', u'', "%s" % mg['BUYIN']))
                 if mg['FEE'] is not None:
                     if tourney.fee is None:
                         tourney.fee = 100*Decimal(re.sub(u',', u'', "%s" % mg['FEE']))
                     else :
                         if 100*Decimal(re.sub(u',', u'', "%s" % mg['FEE'])) != tourney.fee:
-                            log.error( "Conflict between fees read in topline (%s) and in BuyIn field (%s)" % (touney.fee, 100*Decimal(re.sub(u',', u'', "%s" % mg['FEE']))) )
+                            log.error( "Conflict between fees read in topline (%s) and in BuyIn field (%s)" % (tourney.fee, 100*Decimal(re.sub(u',', u'', "%s" % mg['FEE']))) )
                             tourney.subTourneyFee = 100*Decimal(re.sub(u',', u'', "%s" % mg['FEE']))
 
         if tourney.buyin is None:

From 080b7f80c9c2653539b070d6e80b3edb30e19a02 Mon Sep 17 00:00:00 2001
From: Eratosthenes <ray.barker@hughes.net>
Date: Wed, 27 Jan 2010 09:23:12 -0500
Subject: [PATCH 15/17] Compile the " collected" reg ex.

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

diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index eeefbf90..1ea4f322 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -112,6 +112,7 @@ class Fulltilt(HandHistoryConverter):
 # These regexes are for FTP only
     re_Mixed        = re.compile(r'\s\-\s(?P<MIXED>HA|HORSE|HOSE)\s\-\s', re.VERBOSE)
     re_Max          = re.compile("(?P<MAX>\d+)( max)?", re.MULTILINE)
+    re_Collected    = re.compile(" collected")
     # NB: if we ever match "Full Tilt Poker" we should also match "FullTiltPoker", which PT Stud erroneously exports.
 
 
@@ -255,7 +256,6 @@ class Fulltilt(HandHistoryConverter):
 #TODO: Need some date functions to convert to different timezones (Date::Manip for perl rocked for this)
         #hand.starttime = "%d/%02d/%02d %d:%02d:%02d ET" %(int(m.group('YEAR')), int(m.group('MON')), int(m.group('DAY')),
                             ##int(m.group('HR')), int(m.group('MIN')), int(m.group('SEC')))
-#FIXME:        hand.buttonpos = int(m.group('BUTTON'))
 
     def readPlayerStacks(self, hand):
         if hand.gametype['type'] == "ring" :
@@ -264,7 +264,7 @@ class Fulltilt(HandHistoryConverter):
             m = self.re_TourneyPlayerInfo.finditer(hand.handText)
 
         for a in m:
-            if not re.search(" collected", a.group('PNAME')):
+            if not self.re_Collected.search(a.group('PNAME')):
                 hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):

From cd05c1da48c2a61fb871b88eb506536abd56b5ee Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Thu, 28 Jan 2010 01:36:42 +0800
Subject: [PATCH 16/17] Remove unused variable

---
 pyfpdb/PokerStarsToFpdb.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyfpdb/PokerStarsToFpdb.py b/pyfpdb/PokerStarsToFpdb.py
index 09bd0390..2a4fbdb6 100755
--- a/pyfpdb/PokerStarsToFpdb.py
+++ b/pyfpdb/PokerStarsToFpdb.py
@@ -237,7 +237,6 @@ class PokerStars(HandHistoryConverter):
     def readPlayerStacks(self, hand):
         log.debug("readPlayerStacks")
         m = self.re_PlayerInfo.finditer(hand.handText)
-        players = []
         for a in m:
             hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 

From a9f2a261d454a4e4455904e882f79905a11cd8e5 Mon Sep 17 00:00:00 2001
From: Worros <carl.gherardi@gmail.com>
Date: Thu, 28 Jan 2010 01:44:14 +0800
Subject: [PATCH 17/17] Regex fix for Fulltilt player names

"Seat 7: moletrapper collected ($2.50)"
vs
"Seat 7: moletrapper ($2.50)"

The regex update should match the second and not the first.
---
 pyfpdb/FulltiltToFpdb.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/pyfpdb/FulltiltToFpdb.py b/pyfpdb/FulltiltToFpdb.py
index 146fe217..2802f465 100755
--- a/pyfpdb/FulltiltToFpdb.py
+++ b/pyfpdb/FulltiltToFpdb.py
@@ -65,8 +65,8 @@ class Fulltilt(HandHistoryConverter):
                                          (\s\((?P<TURBO>Turbo)\))?)|(?P<UNREADABLE_INFO>.+))
                                     ''', re.VERBOSE)
     re_Button       = re.compile('^The button is in seat #(?P<BUTTON>\d+)', re.MULTILINE)
-    re_PlayerInfo   = re.compile('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\$(?P<CASH>[,.0-9]+)\)$', re.MULTILINE)
-    re_TourneyPlayerInfo   = re.compile('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) \(\$?(?P<CASH>[,.0-9]+)\)(, is sitting out)?$', re.MULTILINE)
+    re_PlayerInfo   = re.compile('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) (?! collected )?\(\$(?P<CASH>[,.0-9]+)\)$', re.MULTILINE)
+    re_TourneyPlayerInfo   = re.compile('Seat (?P<SEAT>[0-9]+): (?P<PNAME>.*) (?! collected )?\(\$?(?P<CASH>[,.0-9]+)\)(, is sitting out)?$', re.MULTILINE)
     re_Board        = re.compile(r"\[(?P<CARDS>.+)\]")
 
     #static regex for tourney purpose
@@ -264,8 +264,7 @@ class Fulltilt(HandHistoryConverter):
             m = self.re_TourneyPlayerInfo.finditer(hand.handText)
 
         for a in m:
-            if not self.re_Collected.search(a.group('PNAME')):
-                hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
+            hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))
 
     def markStreets(self, hand):
         # PREFLOP = ** Dealing down cards **