Merge branch 'master' of git://git.assembla.com/fpdboz

Conflicts:
	pyfpdb/fpdb_import.py

pyfpdb/Database.py

@@ -33,6 +33,7 @@ import string
 
 #    FreePokerTools modules
 import fpdb_db
+import fpdb_simple
 import Configuration
 import SQL
 import Card
@@ -44,7 +45,9 @@ class Database:
         self.connection = self.fdb.db
 
         db_params = c.get_db_parameters()
+        self.import_options = c.get_import_parameters()
         self.type = db_params['db-type']
+        self.backend = db_params['db-backend']
         self.sql = SQL.Sql(game = game, type = self.type, db_server = db_params['db-server'])
         self.connection.rollback()
         
@@ -76,6 +79,11 @@ class Database:
         self.hand_nhands_ago = 0  # todo
         #cur.execute(self.sql.query['get_table_name'], (hand_id, ))
         #row = cur.fetchone()
+        self.saveActions = False if self.import_options['saveActions'] == False else True
+
+
+    def commit(self):
+        self.fdb.db.commit()
 
     def close_connection(self):
         self.connection.close()
@@ -260,6 +268,129 @@ class Database:
         else:
             return None
 
+    def get_last_insert_id(self):
+        return self.fdb.getLastInsertId()
+
+
+    #stores a stud/razz hand into the database
+    def ring_stud(self, config, settings, db, cursor, base, category, site_hand_no, gametype_id, hand_start_time
+                 ,names, player_ids, start_cashes, antes, card_values, card_suits, winnings, rakes
+                 ,action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName
+                 ,seatNos):
+
+        fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+
+        hands_id = fpdb_simple.storeHands(self.backend, db, cursor, site_hand_no, gametype_id
+                                       ,hand_start_time, names, tableName, maxSeats, hudImportData)
+
+        #print "before calling store_hands_players_stud, antes:", antes
+        hands_players_ids = fpdb_simple.store_hands_players_stud(self.backend, db, cursor, hands_id, player_ids
+                                                              ,start_cashes, antes, card_values
+                                                              ,card_suits, winnings, rakes, seatNos)
+
+        if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop':
+            fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
+
+        if self.saveActions:
+            fpdb_simple.storeActions(cursor, hands_players_ids, action_types
+                                    ,allIns, action_amounts, actionNos)
+        return hands_id
+    #end def ring_stud
+
+    def ring_holdem_omaha(self, config, settings, db, cursor, base, category, site_hand_no, gametype_id
+                         ,hand_start_time, names, player_ids, start_cashes, positions, card_values
+                         ,card_suits, board_values, board_suits, winnings, rakes, action_types, allIns
+                         ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
+        """stores a holdem/omaha hand into the database"""
+
+        t0 = time()
+        fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+        t1 = time()
+        fpdb_simple.fill_board_cards(board_values, board_suits)
+        t2 = time()
+
+        hands_id = fpdb_simple.storeHands(self.backend, db, cursor, site_hand_no, gametype_id
+                                       ,hand_start_time, names, tableName, maxSeats,
+                                       hudImportData, board_values, board_suits)
+        #TEMPORARY CALL! - Just until all functions are migrated
+        t3 = time()
+        hands_players_ids = fpdb_simple.store_hands_players_holdem_omaha(
+                                   self.backend, db, cursor, category, hands_id, player_ids, start_cashes
+                                 , positions, card_values, card_suits, winnings, rakes, seatNos, hudImportData)
+        t4 = time()
+        #print "ring holdem, backend=%d" % backend
+        if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop':
+            fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
+        t5 = time()
+        fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
+        t6 = time()
+        if self.saveActions:
+            fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
+        t7 = time()
+        #print "fills=(%4.3f) saves=(%4.3f,%4.3f,%4.3f,%4.3f)" % (t2-t0, t3-t2, t4-t3, t5-t4, t6-t5)
+        return hands_id
+    #end def ring_holdem_omaha
+
+    def tourney_holdem_omaha(self, config, settings, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout
+                            ,entries, prizepool, tourney_start, payin_amounts, ranks, tourneyTypeId
+                            ,siteId #end of tourney specific params
+                            ,site_hand_no, gametype_id, hand_start_time, names, player_ids
+                            ,start_cashes, positions, card_values, card_suits, board_values
+                            ,board_suits, winnings, rakes, action_types, allIns, action_amounts
+                            ,actionNos, hudImportData, maxSeats, tableName, seatNos):
+        """stores a tourney holdem/omaha hand into the database"""
+
+        fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
+        fpdb_simple.fill_board_cards(board_values, board_suits)
+
+        tourney_id = fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourney_start)
+        tourneys_players_ids = fpdb_simple.store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings)
+
+        hands_id = fpdb_simple.storeHands(self.backend, db, cursor, site_hand_no, gametype_id
+                                       ,hand_start_time, names, tableName, maxSeats)
+
+        hands_players_ids = fpdb_simple.store_hands_players_holdem_omaha_tourney(
+                          self.backend, db, cursor, category, hands_id, player_ids, start_cashes, positions
+                        , card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids)
+
+        #print "tourney holdem, backend=%d" % backend
+        if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop':
+            fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
+
+        fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
+
+        if self.saveActions:
+            fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
+        return hands_id
+    #end def tourney_holdem_omaha
+
+    def tourney_stud(self, config, settings, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries
+                    ,prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteId
+                    ,siteHandNo, gametypeId, handStartTime, names, playerIds, startCashes, antes
+                    ,cardValues, cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts
+                    ,actionNos, hudImportData, maxSeats, tableName, seatNos):
+        #stores a tourney stud/razz hand into the database
+
+        fpdb_simple.fillCardArrays(len(names), base, category, cardValues, cardSuits)
+
+        tourney_id = fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourneyStartTime)
+
+        tourneys_players_ids = fpdb_simple.store_tourneys_players(cursor, tourney_id, playerIds, payin_amounts, ranks, winnings)
+
+        hands_id = fpdb_simple.storeHands(self.backend, db, cursor, siteHandNo, gametypeId, handStartTime, names, tableName, maxSeats)
+
+        hands_players_ids = fpdb_simple.store_hands_players_stud_tourney(self.backend, db, cursor, hands_id
+                                                 , playerIds, startCashes, antes, cardValues, cardSuits
+                                                 , winnings, rakes, seatNos, tourneys_players_ids)
+
+        if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop':
+            fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametypeId, hand_start_time, playerIds, hudImportData)
+
+        if self.saveActions:
+            fpdb_simple.storeActions(cursor, hands_players_ids, actionTypes, allIns, actionAmounts, actionNos)
+        return hands_id
+    #end def tourney_stud
+
 if __name__=="__main__":
     c = Configuration.Config()
 

pyfpdb/Hand.py

@@ -111,6 +111,14 @@ db: a connected fpdb_db object"""
              # boardcard3 smallint,
              # boardcard4 smallint,
              # boardcard5 smallint,
+                 # Flop turn and river may all be empty - add (likely) too many elements and trim with range
+                 # boardcards = board['FLOP'] + board['TURN'] + board['RIVER'] + [u'0x', u'0x', u'0x', u'0x', u'0x']
+                 # cards = [Card.cardFromValueSuit(v,s) for v,s in boardcards[0:4]]
+                 # hh['boardcard1'] = cards[0]
+                 # hh['boardcard2'] = cards[1]
+                 # hh['boardcard3'] = cards[2]
+                 # hh['boardcard4'] = cards[3]
+                 # hh['boardcard5'] = cards[4]
              # texture smallint,
              # playersVpi SMALLINT NOT NULL,         /* num of players vpi */
                 # Needs to be recorded
@@ -194,6 +202,7 @@ If a player has None chips he won't be added."""
     def setCommunityCards(self, street, cards):
         logging.debug("setCommunityCards %s %s" %(street,  cards))
         self.board[street] = [self.card(c) for c in cards]
+        print "DEBUG: self.board: %s" % self.board
 
     def card(self,c):
         """upper case the ranks but not suits, 'atjqk' => 'ATJQK'"""

pyfpdb/fpdb_db.py

@@ -598,10 +598,39 @@ class fpdb_db:
                 return(1)
         return(0)
 
+    def getLastInsertId(self):
+        if self.backend == self.MYSQL_INNODB:
+            ret = self.db.insert_id()
+            if ret < 1 or ret > 999999999:
+                print "getLastInsertId(): problem fetching insert_id? ret=", ret
+                ret = -1
+        elif self.backend == self.PGSQL:
+            # some options:
+            # currval(hands_id_seq) - use name of implicit seq here
+            # lastval() - still needs sequences set up?
+            # insert ... returning  is useful syntax (but postgres specific?)
+            # see rules (fancy trigger type things)
+            self.cursor.execute ("SELECT lastval()")
+            row = self.cursor.fetchone()
+            if not row:
+                print "getLastInsertId(%s): problem fetching lastval? row=" % seq, row
+                ret = -1
+            else:
+                ret = row[0]
+        elif self.backend == self.SQLITE:
+            # don't know how to do this in sqlite
+            print "getLastInsertId(): not coded for sqlite yet"
+            ret = -1
+        else:
+            print "getLastInsertId(): unknown backend ", self.backend
+            ret = -1
+        return ret
+
     def storeHand(self, p):
         #stores into table hands:
         self.cursor.execute ("""INSERT INTO Hands 
              (siteHandNo, gametypeId, handStart, seats, tableName, importTime, maxSeats
+              ,boardcard1, boardcard2, boardcard3, boardcard4, boardcard5
               ,playersVpi, playersAtStreet1, playersAtStreet2
               ,playersAtStreet3, playersAtStreet4, playersAtShowdown
               ,street0Raises, street1Raises, street2Raises
@@ -612,6 +641,7 @@ class fpdb_db:
              VALUES 
               (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"""
              ,(p['siteHandNo'], gametype_id, p['handStart'], len(names), p['tableName'], datetime.datetime.today(), p['maxSeats']
+               ,p['boardcard1'], ['boardcard2'], p['boardcard3'], ['boardcard4'], ['boardcard5'] 
                ,hudCache['playersVpi'], hudCache['playersAtStreet1'], hudCache['playersAtStreet2']
                ,hudCache['playersAtStreet3'], hudCache['playersAtStreet4'], hudCache['playersAtShowdown']
                ,hudCache['street0Raises'], hudCache['street1Raises'], hudCache['street2Raises']

pyfpdb/fpdb_import.py

@@ -288,36 +288,34 @@ class Importer:
         if os.path.isdir(file):
             self.addToDirList[file] = [site] + [filter]
             return
-        if filter == "passthrough" or filter == "":
-            (stored, duplicates, partial, errors, ttime) = self.import_fpdb_file(file, site)
-        else:
-            conv = None
-            # Load filter, process file, pass returned filename to import_fpdb_file
 
-            print "\nConverting %s" % file
+        conv = None
-            hhbase    = self.config.get_import_parameters().get("hhArchiveBase")
+        # Load filter, process file, pass returned filename to import_fpdb_file
-            hhbase    = os.path.expanduser(hhbase)
-            hhdir     = os.path.join(hhbase,site)
-            try:
-                out_path     = os.path.join(hhdir, file.split(os.path.sep)[-2]+"-"+os.path.basename(file))
-            except:
-                out_path     = os.path.join(hhdir, "x"+strftime("%d-%m-%y")+os.path.basename(file))
             
-            filter_name = filter.replace("ToFpdb", "")
+        print "\nConverting %s" % file
+        hhbase    = self.config.get_import_parameters().get("hhArchiveBase")
+        hhbase    = os.path.expanduser(hhbase)
+        hhdir     = os.path.join(hhbase,site)
+        try:
+            out_path     = os.path.join(hhdir, file.split(os.path.sep)[-2]+"-"+os.path.basename(file))
+        except:
+            out_path     = os.path.join(hhdir, "x"+strftime("%d-%m-%y")+os.path.basename(file))
 
-            mod = __import__(filter)
+        filter_name = filter.replace("ToFpdb", "")
-            obj = getattr(mod, filter_name, None)
+
-            if callable(obj):
+        mod = __import__(filter)
-                conv = obj(in_path = file, out_path = out_path)
+        obj = getattr(mod, filter_name, None)
-                if(conv.getStatus()):
+        if callable(obj):
-                    (stored, duplicates, partial, errors, ttime) = self.import_fpdb_file(out_path, site)
+            conv = obj(in_path = file, out_path = out_path)
-                else:
+            if(conv.getStatus()):
-                    # conversion didn't work
+                (stored, duplicates, partial, errors, ttime) = self.import_fpdb_file(out_path, site)
-                    # TODO: appropriate response?
-                    return (0, 0, 0, 1, 0)
             else:
-                print "Unknown filter filter_name:'%s' in filter:'%s'" %(filter_name, filter)
+                # conversion didn't work
-                return
+                # TODO: appropriate response?
+                return (0, 0, 0, 1, 0)
+        else:
+            print "Unknown filter filter_name:'%s' in filter:'%s'" %(filter_name, filter)
+            return
 
         #This will barf if conv.getStatus != True
         return (stored, duplicates, partial, errors, ttime)
@@ -394,8 +392,8 @@ class Importer:
                     self.hand=hand
 
                     try:
-                        handsId = fpdb_parse_logic.mainParser(self.settings, self.fdb.db
+                        handsId = fpdb_parse_logic.mainParser(self.settings, self.fdb
-                                                           ,self.fdb.cursor, self.siteIds[site], category, hand, self.config)
+                                                           , self.siteIds[site], category, hand, self.config)
                         self.fdb.db.commit()
 
                         stored += 1

pyfpdb/fpdb_parse_logic.py

@@ -18,11 +18,13 @@
 #methods that are specific to holdem but not trivial
 
 import fpdb_simple
-import fpdb_save_to_db
+import Database
 
 #parses a holdem hand
-def mainParser(settings, db, cursor, siteID, category, hand, config):
+def mainParser(settings, fdb, siteID, category, hand, config):
     backend = settings['db-backend']
+    #This is redundant - hopefully fdb will be a Database object in an interation soon
+    db = Database.Database(config, 'fpdb', '')
     category = fpdb_simple.recogniseCategory(hand[0])
 
     base = "hold" if category == "holdem" or category == "omahahi" or category == "omahahilo" else "stud"
@@ -47,7 +49,7 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
             break
     #print "small blind line:",smallBlindLine
 
-    gametypeID = fpdb_simple.recogniseGametypeID(backend, db, cursor, hand[0], hand[smallBlindLine], siteID, category, isTourney)
+    gametypeID = fpdb_simple.recogniseGametypeID(backend, fdb.db, fdb.cursor, hand[0], hand[smallBlindLine], siteID, category, isTourney)
     if isTourney:
         siteTourneyNo   = fpdb_simple.parseTourneyNo(hand[0])
         buyin           = fpdb_simple.parseBuyin(hand[0])
@@ -58,9 +60,9 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
         tourneyStartTime= handStartTime #todo: read tourney start time
         rebuyOrAddon    = fpdb_simple.isRebuyOrAddon(hand[0])
 
-        tourneyTypeId   = fpdb_simple.recogniseTourneyTypeId(cursor, siteID, buyin, fee, knockout, rebuyOrAddon)
+        tourneyTypeId   = fpdb_simple.recogniseTourneyTypeId(fdb.cursor, siteID, buyin, fee, knockout, rebuyOrAddon)
 
-    fpdb_simple.isAlreadyInDB(cursor, gametypeID, siteHandNo)
+    fpdb_simple.isAlreadyInDB(fdb.cursor, gametypeID, siteHandNo)
     
     hand = fpdb_simple.filterCrap(hand, isTourney)
     
@@ -74,7 +76,7 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
             seatLines.append(line)
 
     names       = fpdb_simple.parseNames(seatLines)
-    playerIDs   = fpdb_simple.recognisePlayerIDs(cursor, names, siteID)
+    playerIDs   = fpdb_simple.recognisePlayerIDs(fdb.cursor, names, siteID)
     tmp         = fpdb_simple.parseCashesAndSeatNos(seatLines)
     startCashes = tmp['startCashes']
     seatNos     = tmp['seatNos']
@@ -113,7 +115,7 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
     tableName   = tableResult['tableName']
     #print "before part5, antes:", antes
     
-    #part 5: final preparations, then call fpdb_save_to_db.* with
+    #part 5: final preparations, then call Database.* with
     #         the arrays as they are - that file will fill them.
     fpdb_simple.convertCardValues(cardValues)
     if base == "hold":
@@ -121,8 +123,8 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
         fpdb_simple.convertBlindBet(actionTypes, actionAmounts)
         fpdb_simple.checkPositions(positions)
         
-    cursor.execute("SELECT limitType FROM Gametypes WHERE id=%s",(gametypeID, ))
+    fdb.cursor.execute("SELECT limitType FROM Gametypes WHERE id=%s",(gametypeID, ))
-    limit_type = cursor.fetchone()[0]
+    limit_type = fdb.cursor.fetchone()[0]
     fpdb_simple.convert3B4B(category, limit_type, actionTypes, actionAmounts)
     
     totalWinnings = sum(winnings)
@@ -143,8 +145,8 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
         payin_amounts = fpdb_simple.calcPayin(len(names), buyin, fee)
         
         if base == "hold":
-            result = fpdb_save_to_db.tourney_holdem_omaha(
+            result = db.tourney_holdem_omaha(
-                                       config, settings, db, cursor, base, category, siteTourneyNo, buyin
+                                       config, settings, fdb.db, fdb.cursor, base, category, siteTourneyNo, buyin
                                      , fee, knockout, entries, prizepool, tourneyStartTime
                                      , payin_amounts, ranks, tourneyTypeId, siteID, siteHandNo
                                      , gametypeID, handStartTime, names, playerIDs, startCashes
@@ -152,8 +154,8 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
                                      , winnings, rakes, actionTypes, allIns, actionAmounts
                                      , actionNos, hudImportData, maxSeats, tableName, seatNos)
         elif base == "stud":
-            result = fpdb_save_to_db.tourney_stud(
+            result = db.tourney_stud(
-                                       config, settings, db, cursor, base, category, siteTourneyNo
+                                       config, settings, fdb.db, fdb.cursor, base, category, siteTourneyNo
                                      , buyin, fee, knockout, entries, prizepool, tourneyStartTime
                                      , payin_amounts, ranks, tourneyTypeId, siteID, siteHandNo
                                      , gametypeID, handStartTime, names, playerIDs, startCashes
@@ -164,23 +166,23 @@ def mainParser(settings, db, cursor, siteID, category, hand, config):
             raise fpdb_simple.FpdbError("unrecognised category")
     else:
         if base == "hold":
-            result = fpdb_save_to_db.ring_holdem_omaha(
+            result = db.ring_holdem_omaha(
-                                       config, settings, db, cursor, base, category, siteHandNo
+                                       config, settings, fdb.db, fdb.cursor, base, category, siteHandNo
                                      , gametypeID, handStartTime, names, playerIDs
                                      , startCashes, positions, cardValues, cardSuits
                                      , boardValues, boardSuits, winnings, rakes
                                      , actionTypes, allIns, actionAmounts, actionNos
                                      , hudImportData, maxSeats, tableName, seatNos)
         elif base == "stud":
-            result = fpdb_save_to_db.ring_stud(
+            result = db.ring_stud(
-                                       config, settings, db, cursor, base, category, siteHandNo, gametypeID
+                                       config, settings, fdb.db, fdb.cursor, base, category, siteHandNo, gametypeID
                                      , handStartTime, names, playerIDs, startCashes, antes
                                      , cardValues, cardSuits, winnings, rakes, actionTypes, allIns
                                      , actionAmounts, actionNos, hudImportData, maxSeats, tableName
                                      , seatNos)
         else:
             raise fpdb_simple.FpdbError ("unrecognised category")
-    db.commit()
+    fdb.db.commit()
     return result
 #end def mainParser
 

pyfpdb/fpdb_save_to_db.py

@@ -1,174 +0,0 @@
-#!/usr/bin/python
-
-#Copyright 2008 Steffen Jobbagy-Felso
-#This program is free software: you can redistribute it and/or modify
-#it under the terms of the GNU Affero General Public License as published by
-#the Free Software Foundation, version 3 of the License.
-#
-#This program is distributed in the hope that it will be useful,
-#but WITHOUT ANY WARRANTY; without even the implied warranty of
-#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-#GNU General Public License for more details.
-#
-#You should have received a copy of the GNU Affero General Public License
-#along with this program. If not, see <http://www.gnu.org/licenses/>.
-#In the "official" distribution you can find the license in
-#agpl-3.0.txt in the docs folder of the package.
-
-#This file contains methods to store hands into the db. decides to move this
-#into a seperate file since its ugly, fairly long and just generally in the way.
-
-from time import time
-
-import fpdb_simple
-
-MYSQL_INNODB    = 2
-PGSQL           = 3
-SQLITE          = 4
-
-fastStoreHudCache = False   # set this to True to test the new storeHudCache routine
-
-saveActions = True  # set this to False to avoid storing action data
-                    # Pros: speeds up imports
-                    # Cons: no action data is saved, so you need to keep the hand histories
-                    #       variance not available on stats page
-                    #     : No graphs
-#stores a stud/razz hand into the database
-def ring_stud(config, backend, db, cursor, base, category, site_hand_no, gametype_id, hand_start_time
-             ,names, player_ids, start_cashes, antes, card_values, card_suits, winnings, rakes
-             ,action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName
-             ,seatNos):
-
-    import_options = config.get_import_parameters()
-    
-    saveActions = False if import_options['saveActions'] == False else True
-    fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False
-
-    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-    
-    hands_id = fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
-                                   ,hand_start_time, names, tableName, maxSeats, hudImportData)
-    
-    #print "before calling store_hands_players_stud, antes:", antes
-    hands_players_ids = fpdb_simple.store_hands_players_stud(backend, db, cursor, hands_id, player_ids
-                                                          ,start_cashes, antes, card_values
-                                                          ,card_suits, winnings, rakes, seatNos)
-    
-    fpdb_simple.storeHudCache(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
-    
-    if saveActions:
-        fpdb_simple.storeActions(cursor, hands_players_ids, action_types
-                                ,allIns, action_amounts, actionNos)
-    return hands_id
-#end def ring_stud
-
-def ring_holdem_omaha(config, backend, db, cursor, base, category, site_hand_no, gametype_id
-                     ,hand_start_time, names, player_ids, start_cashes, positions, card_values
-                     ,card_suits, board_values, board_suits, winnings, rakes, action_types, allIns
-                     ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos):
-    """stores a holdem/omaha hand into the database"""
-
-    import_options = config.get_import_parameters()
-    saveActions = False if import_options['saveActions'] == False else True
-    fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False
-
-#   print "DEBUG: saveActions = '%s' fastStoreHudCache = '%s'"%(saveActions, fastStoreHudCache)
-#   print "DEBUG: import_options = ", import_options
-
-    t0 = time()
-    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-    t1 = time()
-    fpdb_simple.fill_board_cards(board_values, board_suits)
-    t2 = time()
-
-    hands_id = fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
-                                   ,hand_start_time, names, tableName, maxSeats,
-                                   hudImportData, board_values, board_suits)
-    t3 = time()
-    hands_players_ids = fpdb_simple.store_hands_players_holdem_omaha(
-                               backend, db, cursor, category, hands_id, player_ids, start_cashes
-                             , positions, card_values, card_suits, winnings, rakes, seatNos, hudImportData)
-    t4 = time()            
-    #print "ring holdem, backend=%d" % backend
-    if fastStoreHudCache:
-        fpdb_simple.storeHudCache2(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
-    else:
-        fpdb_simple.storeHudCache(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
-    t5 = time()
-    fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
-    t6 = time()
-    if saveActions:
-        fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
-    t7 = time()
-    #print "fills=(%4.3f) saves=(%4.3f,%4.3f,%4.3f,%4.3f)" % (t2-t0, t3-t2, t4-t3, t5-t4, t6-t5)
-    return hands_id
-#end def ring_holdem_omaha
-
-def tourney_holdem_omaha(config, backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout
-                        ,entries, prizepool, tourney_start, payin_amounts, ranks, tourneyTypeId
-                        ,siteId #end of tourney specific params
-                        ,site_hand_no, gametype_id, hand_start_time, names, player_ids
-                        ,start_cashes, positions, card_values, card_suits, board_values
-                        ,board_suits, winnings, rakes, action_types, allIns, action_amounts
-                        ,actionNos, hudImportData, maxSeats, tableName, seatNos):
-    """stores a tourney holdem/omaha hand into the database"""
-
-    import_options = config.get_import_parameters()
-    saveActions = True if import_options['saveActions'] == True else False
-    fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False
-
-    fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits)
-    fpdb_simple.fill_board_cards(board_values, board_suits)
-    
-    tourney_id = fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourney_start)
-    tourneys_players_ids = fpdb_simple.store_tourneys_players(cursor, tourney_id, player_ids, payin_amounts, ranks, winnings)
-    
-    hands_id = fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
-                                   ,hand_start_time, names, tableName, maxSeats)
-    
-    hands_players_ids = fpdb_simple.store_hands_players_holdem_omaha_tourney(
-                      backend, db, cursor, category, hands_id, player_ids, start_cashes, positions
-                    , card_values, card_suits, winnings, rakes, seatNos, tourneys_players_ids)
-    
-    #print "tourney holdem, backend=%d" % backend
-    if fastStoreHudCache:
-        fpdb_simple.storeHudCache2(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
-    else:
-        fpdb_simple.storeHudCache(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData)
-    
-    fpdb_simple.store_board_cards(cursor, hands_id, board_values, board_suits)
-    
-    if saveActions:
-        fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos)
-    return hands_id
-#end def tourney_holdem_omaha
-
-def tourney_stud(config, backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries
-                ,prizepool, tourneyStartTime, payin_amounts, ranks, tourneyTypeId, siteId
-                ,siteHandNo, gametypeId, handStartTime, names, playerIds, startCashes, antes
-                ,cardValues, cardSuits, winnings, rakes, actionTypes, allIns, actionAmounts
-                ,actionNos, hudImportData, maxSeats, tableName, seatNos):
-#stores a tourney stud/razz hand into the database
-
-    import_options = config.get_import_parameters()
-    saveActions = True if import_options['saveActions'] == True else False
-    fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False
-    
-    fpdb_simple.fillCardArrays(len(names), base, category, cardValues, cardSuits)
-    
-    tourney_id = fpdb_simple.store_tourneys(cursor, tourneyTypeId, siteTourneyNo, entries, prizepool, tourneyStartTime)
-    
-    tourneys_players_ids = fpdb_simple.store_tourneys_players(cursor, tourney_id, playerIds, payin_amounts, ranks, winnings)
-    
-    hands_id = fpdb_simple.storeHands(backend, db, cursor, siteHandNo, gametypeId, handStartTime, names, tableName, maxSeats)
-    
-    hands_players_ids = fpdb_simple.store_hands_players_stud_tourney(backend, db, cursor, hands_id
-                                             , playerIds, startCashes, antes, cardValues, cardSuits
-                                             , winnings, rakes, seatNos, tourneys_players_ids)
-    
-    fpdb_simple.storeHudCache(backend, cursor, base, category, gametypeId, hand_start_time, playerIds, hudImportData)
-    
-    if saveActions:
-        fpdb_simple.storeActions(cursor, hands_players_ids, actionTypes, allIns, actionAmounts, actionNos)
-    return hands_id
-#end def tourney_stud

pyfpdb/fpdb_simple.py

@@ -2126,189 +2126,6 @@ def storeHudCache(backend, cursor, base, category, gametypeId, hand_start_time,
             # hard-code styleKey as 'A000000' (all-time cache, no key) for now
             styleKey = 'A000000'
         
-        #print "storeHudCache, len(playerIds)=", len(playerIds), " len(vpip)=" \
-        #, len(hudImportData['street0VPI']), " len(totprof)=", len(hudImportData['totalProfit'])
-        for player in xrange(len(playerIds)):
-            
-            # Set up a clean row
-            row=[]
-            row.append(0)#blank for id
-            row.append(gametypeId)
-            row.append(playerIds[player])
-            row.append(len(playerIds))#seats
-            for i in xrange(len(hudImportData)+2):
-                row.append(0)
-                
-            if base=="hold":
-                row[4]=hudImportData['position'][player]
-            else:
-                row[4]=0
-            row[5]=1 #tourneysGametypeId
-            row[6]+=1 #HDs
-            if hudImportData['street0VPI'][player]: row[7]+=1
-            if hudImportData['street0Aggr'][player]: row[8]+=1
-            if hudImportData['street0_3BChance'][player]: row[9]+=1
-            if hudImportData['street0_3BDone'][player]: row[10]+=1
-            if hudImportData['street1Seen'][player]: row[11]+=1
-            if hudImportData['street2Seen'][player]: row[12]+=1
-            if hudImportData['street3Seen'][player]: row[13]+=1
-            if hudImportData['street4Seen'][player]: row[14]+=1
-            if hudImportData['sawShowdown'][player]: row[15]+=1
-            if hudImportData['street1Aggr'][player]: row[16]+=1
-            if hudImportData['street2Aggr'][player]: row[17]+=1
-            if hudImportData['street3Aggr'][player]: row[18]+=1
-            if hudImportData['street4Aggr'][player]: row[19]+=1
-            if hudImportData['otherRaisedStreet1'][player]: row[20]+=1
-            if hudImportData['otherRaisedStreet2'][player]: row[21]+=1
-            if hudImportData['otherRaisedStreet3'][player]: row[22]+=1
-            if hudImportData['otherRaisedStreet4'][player]: row[23]+=1
-            if hudImportData['foldToOtherRaisedStreet1'][player]: row[24]+=1
-            if hudImportData['foldToOtherRaisedStreet2'][player]: row[25]+=1
-            if hudImportData['foldToOtherRaisedStreet3'][player]: row[26]+=1
-            if hudImportData['foldToOtherRaisedStreet4'][player]: row[27]+=1
-            if hudImportData['wonWhenSeenStreet1'][player]!=0.0: row[28]+=hudImportData['wonWhenSeenStreet1'][player]
-            if hudImportData['wonAtSD'][player]!=0.0: row[29]+=hudImportData['wonAtSD'][player]
-            if hudImportData['stealAttemptChance'][player]: row[30]+=1
-            if hudImportData['stealAttempted'][player]: row[31]+=1
-            if hudImportData['foldBbToStealChance'][player]: row[32]+=1
-            if hudImportData['foldedBbToSteal'][player]: row[33]+=1
-            if hudImportData['foldSbToStealChance'][player]: row[34]+=1
-            if hudImportData['foldedSbToSteal'][player]: row[35]+=1
-            
-            if hudImportData['street1CBChance'][player]: row[36]+=1
-            if hudImportData['street1CBDone'][player]: row[37]+=1
-            if hudImportData['street2CBChance'][player]: row[38]+=1
-            if hudImportData['street2CBDone'][player]: row[39]+=1
-            if hudImportData['street3CBChance'][player]: row[40]+=1
-            if hudImportData['street3CBDone'][player]: row[41]+=1
-            if hudImportData['street4CBChance'][player]: row[42]+=1
-            if hudImportData['street4CBDone'][player]: row[43]+=1
-            
-            if hudImportData['foldToStreet1CBChance'][player]: row[44]+=1
-            if hudImportData['foldToStreet1CBDone'][player]: row[45]+=1
-            if hudImportData['foldToStreet2CBChance'][player]: row[46]+=1
-            if hudImportData['foldToStreet2CBDone'][player]: row[47]+=1
-            if hudImportData['foldToStreet3CBChance'][player]: row[48]+=1
-            if hudImportData['foldToStreet3CBDone'][player]: row[49]+=1
-            if hudImportData['foldToStreet4CBChance'][player]: row[50]+=1
-            if hudImportData['foldToStreet4CBDone'][player]: row[51]+=1
- 
-            #print "player=", player
-            #print "len(totalProfit)=", len(hudImportData['totalProfit'])
-            if hudImportData['totalProfit'][player]:
-                row[52]+=hudImportData['totalProfit'][player]
- 
-            if hudImportData['street1CheckCallRaiseChance'][player]: row[53]+=1
-            if hudImportData['street1CheckCallRaiseDone'][player]: row[54]+=1
-            if hudImportData['street2CheckCallRaiseChance'][player]: row[55]+=1
-            if hudImportData['street2CheckCallRaiseDone'][player]: row[56]+=1
-            if hudImportData['street3CheckCallRaiseChance'][player]: row[57]+=1
-            if hudImportData['street3CheckCallRaiseDone'][player]: row[58]+=1
-            if hudImportData['street4CheckCallRaiseChance'][player]: row[59]+=1
-            if hudImportData['street4CheckCallRaiseDone'][player]: row[60]+=1
-            
-            # Try to do the update first:
-            num = cursor.execute("""UPDATE HudCache
-SET HDs=HDs+%s, street0VPI=street0VPI+%s, street0Aggr=street0Aggr+%s,
-    street0_3BChance=street0_3BChance+%s, street0_3BDone=street0_3BDone+%s,
-    street1Seen=street1Seen+%s, street2Seen=street2Seen+%s, street3Seen=street3Seen+%s,
-    street4Seen=street4Seen+%s, sawShowdown=sawShowdown+%s,
-    street1Aggr=street1Aggr+%s, street2Aggr=street2Aggr+%s, street3Aggr=street3Aggr+%s,
-    street4Aggr=street4Aggr+%s, otherRaisedStreet1=otherRaisedStreet1+%s,
-    otherRaisedStreet2=otherRaisedStreet2+%s, otherRaisedStreet3=otherRaisedStreet3+%s,
-    otherRaisedStreet4=otherRaisedStreet4+%s,
-    foldToOtherRaisedStreet1=foldToOtherRaisedStreet1+%s, foldToOtherRaisedStreet2=foldToOtherRaisedStreet2+%s,
-    foldToOtherRaisedStreet3=foldToOtherRaisedStreet3+%s, foldToOtherRaisedStreet4=foldToOtherRaisedStreet4+%s,
-    wonWhenSeenStreet1=wonWhenSeenStreet1+%s, wonAtSD=wonAtSD+%s, stealAttemptChance=stealAttemptChance+%s,
-    stealAttempted=stealAttempted+%s, foldBbToStealChance=foldBbToStealChance+%s,
-    foldedBbToSteal=foldedBbToSteal+%s,
-    foldSbToStealChance=foldSbToStealChance+%s, foldedSbToSteal=foldedSbToSteal+%s,
-    street1CBChance=street1CBChance+%s, street1CBDone=street1CBDone+%s, street2CBChance=street2CBChance+%s,
-    street2CBDone=street2CBDone+%s, street3CBChance=street3CBChance+%s,
-    street3CBDone=street3CBDone+%s, street4CBChance=street4CBChance+%s, street4CBDone=street4CBDone+%s,
-    foldToStreet1CBChance=foldToStreet1CBChance+%s, foldToStreet1CBDone=foldToStreet1CBDone+%s,
-    foldToStreet2CBChance=foldToStreet2CBChance+%s, foldToStreet2CBDone=foldToStreet2CBDone+%s,
-    foldToStreet3CBChance=foldToStreet3CBChance+%s,
-    foldToStreet3CBDone=foldToStreet3CBDone+%s, foldToStreet4CBChance=foldToStreet4CBChance+%s,
-    foldToStreet4CBDone=foldToStreet4CBDone+%s, totalProfit=totalProfit+%s,
-    street1CheckCallRaiseChance=street1CheckCallRaiseChance+%s,
-    street1CheckCallRaiseDone=street1CheckCallRaiseDone+%s, street2CheckCallRaiseChance=street2CheckCallRaiseChance+%s,
-    street2CheckCallRaiseDone=street2CheckCallRaiseDone+%s, street3CheckCallRaiseChance=street3CheckCallRaiseChance+%s,
-    street3CheckCallRaiseDone=street3CheckCallRaiseDone+%s, street4CheckCallRaiseChance=street4CheckCallRaiseChance+%s,
-    street4CheckCallRaiseDone=street4CheckCallRaiseDone+%s
-WHERE gametypeId+0=%s 
-AND   playerId=%s 
-AND   activeSeats=%s 
-AND   position=%s 
-AND   tourneyTypeId+0=%s
-AND   styleKey=%s
-                      """, (row[6], row[7], row[8], row[9], row[10],
-                            row[11], row[12], row[13], row[14], row[15],
-                            row[16], row[17], row[18], row[19], row[20],
-                            row[21], row[22], row[23], row[24], row[25],
-                            row[26], row[27], row[28], row[29], row[30],
-                            row[31], row[32], row[33], row[34], row[35],
-                            row[36], row[37], row[38], row[39], row[40],
-                            row[41], row[42], row[43], row[44], row[45],
-                            row[46], row[47], row[48], row[49], row[50],
-                            row[51], row[52], row[53], row[54], row[55],
-                            row[56], row[57], row[58], row[59], row[60],
-                            row[1], row[2], row[3], str(row[4]), row[5], styleKey))
-            # Test statusmessage to see if update worked, do insert if not
-            #print "storehud2, upd num =", num
-            if (   (backend == PGSQL and cursor.statusmessage != "UPDATE 1")
-                or (backend == MYSQL_INNODB and num == 0) ):
-                #print "playerid before insert:",row[2]," num = ", num
-                cursor.execute("""INSERT INTO HudCache
-(gametypeId, playerId, activeSeats, position, tourneyTypeId, styleKey,
-HDs, street0VPI, street0Aggr, street0_3BChance, street0_3BDone,
-street1Seen, street2Seen, street3Seen, street4Seen, sawShowdown,
-street1Aggr, street2Aggr, street3Aggr, street4Aggr, otherRaisedStreet1,
-otherRaisedStreet2, otherRaisedStreet3, otherRaisedStreet4, foldToOtherRaisedStreet1, foldToOtherRaisedStreet2,
-foldToOtherRaisedStreet3, foldToOtherRaisedStreet4, wonWhenSeenStreet1, wonAtSD, stealAttemptChance,
-stealAttempted, foldBbToStealChance, foldedBbToSteal, foldSbToStealChance, foldedSbToSteal,
-street1CBChance, street1CBDone, street2CBChance, street2CBDone, street3CBChance,
-street3CBDone, street4CBChance, street4CBDone, foldToStreet1CBChance, foldToStreet1CBDone,
-foldToStreet2CBChance, foldToStreet2CBDone, foldToStreet3CBChance, foldToStreet3CBDone, foldToStreet4CBChance,
-foldToStreet4CBDone, totalProfit, street1CheckCallRaiseChance, street1CheckCallRaiseDone, street2CheckCallRaiseChance,
-street2CheckCallRaiseDone, street3CheckCallRaiseChance, street3CheckCallRaiseDone, street4CheckCallRaiseChance, street4CheckCallRaiseDone)
-VALUES (%s, %s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s,
-%s, %s, %s, %s, %s)"""
-                              , (row[1], row[2], row[3], row[4], row[5], styleKey, row[6], row[7], row[8], row[9], row[10]
-                                ,row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19], row[20]
-                                ,row[21], row[22], row[23], row[24], row[25], row[26], row[27], row[28], row[29], row[30]
-                                ,row[31], row[32], row[33], row[34], row[35], row[36], row[37], row[38], row[39], row[40]
-                                ,row[41], row[42], row[43], row[44], row[45], row[46], row[47], row[48], row[49], row[50]
-                                ,row[51], row[52], row[53], row[54], row[55], row[56], row[57], row[58], row[59], row[60]) )
-                #print "hopefully inserted hud data line: ", cursor.statusmessage
-                # message seems to be "INSERT 0 1"
-            else:
-                #print "updated(2) hud data line"
-                pass
-# else:
-# print "todo: implement storeHudCache for stud base"
-#end def storeHudCache
- 
-def storeHudCache2(backend, cursor, base, category, gametypeId, hand_start_time, playerIds, hudImportData):
-        """Modified version aiming for more speed ..."""
-# if (category=="holdem" or category=="omahahi" or category=="omahahilo"):
-        if use_date_in_hudcache:
-            #print "key =", "d%02d%02d%02d " % (hand_start_time.year-2000, hand_start_time.month, hand_start_time.day)
-            styleKey = "d%02d%02d%02d" % (hand_start_time.year-2000, hand_start_time.month, hand_start_time.day)
-        else:
-            # hard-code styleKey as 'A000000' (all-time cache, no key) for now
-            styleKey = 'A000000'
-        
         #print "storeHudCache2, len(playerIds)=", len(playerIds), " len(vpip)=" \
         #, len(hudImportData['street0VPI']), " len(totprof)=", len(hudImportData['totalProfit'])
         for player in xrange(len(playerIds)):