From fdf4b65136f8e0d1c7f9cde859bb3de759ca33cd Mon Sep 17 00:00:00 2001 From: sqlcoder Date: Tue, 9 Jun 2009 22:55:18 +0100 Subject: [PATCH 1/8] pass all settings through so that a new one can be used to skip updating hudcache (not used yet) --- pyfpdb/fpdb_import.py | 2 +- pyfpdb/fpdb_save_to_db.py | 36 ++++++++++++++++++++++-------------- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/pyfpdb/fpdb_import.py b/pyfpdb/fpdb_import.py index 99330bb9..3fa20b40 100644 --- a/pyfpdb/fpdb_import.py +++ b/pyfpdb/fpdb_import.py @@ -394,7 +394,7 @@ class Importer: self.hand=hand try: - handsId = fpdb_parse_logic.mainParser(self.settings['db-backend'], self.fdb.db + handsId = fpdb_parse_logic.mainParser(self.settings, self.fdb.db ,self.fdb.cursor, self.siteIds[site], category, hand, self.config) self.fdb.db.commit() diff --git a/pyfpdb/fpdb_save_to_db.py b/pyfpdb/fpdb_save_to_db.py index e612a166..b6e8686c 100644 --- a/pyfpdb/fpdb_save_to_db.py +++ b/pyfpdb/fpdb_save_to_db.py @@ -34,11 +34,12 @@ saveActions = True # set this to False to avoid storing action data # 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 +def ring_stud(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): + backend = settings['db-backend'] import_options = config.get_import_parameters() saveActions = False if import_options['saveActions'] == False else True @@ -54,7 +55,8 @@ def ring_stud(config, backend, db, cursor, base, category, site_hand_no, gametyp ,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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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 @@ -62,12 +64,13 @@ def ring_stud(config, backend, db, cursor, base, category, site_hand_no, gametyp return hands_id #end def ring_stud -def ring_holdem_omaha(config, backend, db, cursor, base, category, site_hand_no, gametype_id +def ring_holdem_omaha(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""" + backend = settings['db-backend'] import_options = config.get_import_parameters() saveActions = False if import_options['saveActions'] == False else True fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False @@ -90,10 +93,11 @@ def ring_holdem_omaha(config, backend, db, cursor, base, category, site_hand_no, , 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) + if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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() @@ -104,7 +108,7 @@ def ring_holdem_omaha(config, backend, db, cursor, base, category, site_hand_no, return hands_id #end def ring_holdem_omaha -def tourney_holdem_omaha(config, backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout +def tourney_holdem_omaha(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 @@ -113,6 +117,7 @@ def tourney_holdem_omaha(config, backend, db, cursor, base, category, siteTourne ,actionNos, hudImportData, maxSeats, tableName, seatNos): """stores a tourney holdem/omaha hand into the database""" + backend = settings['db-backend'] import_options = config.get_import_parameters() saveActions = True if import_options['saveActions'] == True else False fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False @@ -131,10 +136,11 @@ def tourney_holdem_omaha(config, backend, db, cursor, base, category, siteTourne , 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) + if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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) @@ -143,13 +149,14 @@ def tourney_holdem_omaha(config, backend, db, cursor, base, category, siteTourne return hands_id #end def tourney_holdem_omaha -def tourney_stud(config, backend, db, cursor, base, category, siteTourneyNo, buyin, fee, knockout, entries +def tourney_stud(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 + backend = settings['db-backend'] import_options = config.get_import_parameters() saveActions = True if import_options['saveActions'] == True else False fastStoreHudCache = True if import_options['fastStoreHudCache'] == True else False @@ -166,7 +173,8 @@ def tourney_stud(config, backend, db, cursor, base, category, siteTourneyNo, buy , 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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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) From f1921bebdea33ab3c6624bce7356c750e3fa2d56 Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 04:15:52 +0800 Subject: [PATCH 2/8] Move functions from fpdb_save_to_db into Database.py Doesn't actually do much cleanup. Intend on moving all db functions into Database.py and fpdb_db.py and providing and API, the functionality of fpdb_simple et all to shift into the HHC --- pyfpdb/Database.py | 167 ++++++++++++++++++++++++++++++++++ pyfpdb/fpdb_import.py | 4 +- pyfpdb/fpdb_parse_logic.py | 38 ++++---- pyfpdb/fpdb_save_to_db.py | 182 ------------------------------------- 4 files changed, 189 insertions(+), 202 deletions(-) diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py index f8dd8f0d..7c13283c 100755 --- a/pyfpdb/Database.py +++ b/pyfpdb/Database.py @@ -33,6 +33,7 @@ import string # FreePokerTools modules import fpdb_db +import fpdb_simple import Configuration import SQL import Card @@ -77,6 +78,9 @@ class Database: #cur.execute(self.sql.query['get_table_name'], (hand_id, )) #row = cur.fetchone() + def commit(self): + self.fdb.db.commit() + def close_connection(self): self.connection.close() @@ -264,6 +268,169 @@ class Database: else: return None +#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(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): + + backend = settings['db-backend'] + 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) + + if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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(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""" + + backend = settings['db-backend'] + 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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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(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""" + + backend = settings['db-backend'] + 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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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(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 + + backend = settings['db-backend'] + 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) + + if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': + 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 + if __name__=="__main__": c = Configuration.Config() diff --git a/pyfpdb/fpdb_import.py b/pyfpdb/fpdb_import.py index 3fa20b40..99411573 100644 --- a/pyfpdb/fpdb_import.py +++ b/pyfpdb/fpdb_import.py @@ -394,8 +394,8 @@ class Importer: self.hand=hand try: - handsId = fpdb_parse_logic.mainParser(self.settings, self.fdb.db - ,self.fdb.cursor, self.siteIds[site], category, hand, self.config) + handsId = fpdb_parse_logic.mainParser(self.settings, self.fdb + , self.siteIds[site], category, hand, self.config) self.fdb.db.commit() stored += 1 diff --git a/pyfpdb/fpdb_parse_logic.py b/pyfpdb/fpdb_parse_logic.py index ee5d9c40..eff8179f 100644 --- a/pyfpdb/fpdb_parse_logic.py +++ b/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, )) - limit_type = cursor.fetchone()[0] + fdb.cursor.execute("SELECT limitType FROM Gametypes WHERE id=%s",(gametypeID, )) + 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( - config, settings, db, cursor, base, category, siteTourneyNo, buyin + result = db.tourney_holdem_omaha( + 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( - config, settings, db, cursor, base, category, siteTourneyNo + result = db.tourney_stud( + 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( - config, settings, db, cursor, base, category, siteHandNo + result = db.ring_holdem_omaha( + 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( - config, settings, db, cursor, base, category, siteHandNo, gametypeID + result = db.ring_stud( + 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 diff --git a/pyfpdb/fpdb_save_to_db.py b/pyfpdb/fpdb_save_to_db.py index b6e8686c..e69de29b 100644 --- a/pyfpdb/fpdb_save_to_db.py +++ b/pyfpdb/fpdb_save_to_db.py @@ -1,182 +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 . -#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, 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): - - backend = settings['db-backend'] - 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) - - if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - 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, 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""" - - backend = settings['db-backend'] - 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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - 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, 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""" - - backend = settings['db-backend'] - 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 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - 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, 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 - - backend = settings['db-backend'] - 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) - - if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - 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 From 2b3e507a3c5cd2a5e7ed09d1b87e00f221f0a32f Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 05:33:33 +0800 Subject: [PATCH 3/8] Factor out some common code --- pyfpdb/Database.py | 80 +++++++++++++++------------------------------- 1 file changed, 25 insertions(+), 55 deletions(-) diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py index 7c13283c..b394622a 100755 --- a/pyfpdb/Database.py +++ b/pyfpdb/Database.py @@ -45,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() @@ -77,6 +79,9 @@ 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 + self.fastStoreHudCache = True if self.import_options['fastStoreHudCache'] == True else False + def commit(self): self.fdb.db.commit() @@ -268,20 +273,6 @@ class Database: else: return None -#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(self, config, settings, db, cursor, base, category, site_hand_no, gametype_id, hand_start_time @@ -289,26 +280,20 @@ class Database: ,action_types, allIns, action_amounts, actionNos, hudImportData, maxSeats, tableName ,seatNos): - backend = settings['db-backend'] - 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 + 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(backend, db, cursor, hands_id, player_ids + 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(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) + fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) - if saveActions: + if self.saveActions: fpdb_simple.storeActions(cursor, hands_players_ids, action_types ,allIns, action_amounts, actionNos) return hands_id @@ -320,11 +305,6 @@ class Database: ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos): """stores a holdem/omaha hand into the database""" - backend = settings['db-backend'] - 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 @@ -334,24 +314,24 @@ class Database: fpdb_simple.fill_board_cards(board_values, board_suits) t2 = time() - hands_id = fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id + 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) t3 = time() hands_players_ids = fpdb_simple.store_hands_players_holdem_omaha( - backend, db, cursor, category, hands_id, player_ids, start_cashes + 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': - if fastStoreHudCache: - fpdb_simple.storeHudCache2(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) + if self.fastStoreHudCache: + fpdb_simple.storeHudCache2(self.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.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 saveActions: + 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) @@ -367,34 +347,29 @@ class Database: ,actionNos, hudImportData, maxSeats, tableName, seatNos): """stores a tourney holdem/omaha hand into the database""" - backend = settings['db-backend'] - 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 + 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( - backend, db, cursor, category, hands_id, player_ids, start_cashes, positions + 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': - if fastStoreHudCache: - fpdb_simple.storeHudCache2(backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) + if self.fastStoreHudCache: + fpdb_simple.storeHudCache2(self.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.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 saveActions: + if self.saveActions: fpdb_simple.storeActions(cursor, hands_players_ids, action_types, allIns, action_amounts, actionNos) return hands_id #end def tourney_holdem_omaha @@ -406,27 +381,22 @@ class Database: ,actionNos, hudImportData, maxSeats, tableName, seatNos): #stores a tourney stud/razz hand into the database - backend = settings['db-backend'] - 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_id = fpdb_simple.storeHands(self.backend, db, cursor, siteHandNo, gametypeId, handStartTime, names, tableName, maxSeats) - hands_players_ids = fpdb_simple.store_hands_players_stud_tourney(backend, db, cursor, hands_id + 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(backend, cursor, base, category, gametypeId, hand_start_time, playerIds, hudImportData) + fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametypeId, hand_start_time, playerIds, hudImportData) - if saveActions: + if self.saveActions: fpdb_simple.storeActions(cursor, hands_players_ids, actionTypes, allIns, actionAmounts, actionNos) return hands_id #end def tourney_stud From 2569eeddc813304fd5a1b4bfe79d5ecc4611c8d4 Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 05:37:30 +0800 Subject: [PATCH 4/8] Remve legacy storeHudCache function --- pyfpdb/Database.py | 12 +-- pyfpdb/fpdb_simple.py | 183 ------------------------------------------ 2 files changed, 2 insertions(+), 193 deletions(-) diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py index b394622a..2762143e 100755 --- a/pyfpdb/Database.py +++ b/pyfpdb/Database.py @@ -80,7 +80,6 @@ class Database: #cur.execute(self.sql.query['get_table_name'], (hand_id, )) #row = cur.fetchone() self.saveActions = False if self.import_options['saveActions'] == False else True - self.fastStoreHudCache = True if self.import_options['fastStoreHudCache'] == True else False def commit(self): @@ -305,7 +304,6 @@ class Database: ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos): """stores a holdem/omaha hand into the database""" - # print "DEBUG: saveActions = '%s' fastStoreHudCache = '%s'"%(saveActions, fastStoreHudCache) # print "DEBUG: import_options = ", import_options t0 = time() @@ -324,10 +322,7 @@ class Database: t4 = time() #print "ring holdem, backend=%d" % backend if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - if self.fastStoreHudCache: - fpdb_simple.storeHudCache2(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) - else: - fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) + 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() @@ -362,10 +357,7 @@ class Database: #print "tourney holdem, backend=%d" % backend if 'updateHudCache' not in settings or settings['updateHudCache'] != 'drop': - if self.fastStoreHudCache: - fpdb_simple.storeHudCache2(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) - else: - fpdb_simple.storeHudCache(self.backend, cursor, base, category, gametype_id, hand_start_time, player_ids, hudImportData) + 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) diff --git a/pyfpdb/fpdb_simple.py b/pyfpdb/fpdb_simple.py index 398a20e5..34f99e2f 100644 --- a/pyfpdb/fpdb_simple.py +++ b/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)): From 864e37ddc863d76b8a50de1beb4a0edf870d3fd8 Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 05:38:33 +0800 Subject: [PATCH 5/8] Remove empty file --- pyfpdb/fpdb_save_to_db.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 pyfpdb/fpdb_save_to_db.py diff --git a/pyfpdb/fpdb_save_to_db.py b/pyfpdb/fpdb_save_to_db.py deleted file mode 100644 index e69de29b..00000000 From d00031edf7d161cc4ec2c319e644d1063156501c Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 06:22:57 +0800 Subject: [PATCH 6/8] Add get_last_insert_id() to Database API --- pyfpdb/Database.py | 6 ++++-- pyfpdb/fpdb_db.py | 30 +++++++++++++++++++++++++++++- 2 files changed, 33 insertions(+), 3 deletions(-) diff --git a/pyfpdb/Database.py b/pyfpdb/Database.py index 2762143e..932a8578 100755 --- a/pyfpdb/Database.py +++ b/pyfpdb/Database.py @@ -272,6 +272,9 @@ 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 @@ -304,8 +307,6 @@ class Database: ,action_amounts, actionNos, hudImportData, maxSeats, tableName, seatNos): """stores a holdem/omaha hand into the database""" - # print "DEBUG: import_options = ", import_options - t0 = time() fpdb_simple.fillCardArrays(len(names), base, category, card_values, card_suits) t1 = time() @@ -315,6 +316,7 @@ class Database: 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 diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py index 86776b82..201b98fd 100644 --- a/pyfpdb/fpdb_db.py +++ b/pyfpdb/fpdb_db.py @@ -596,7 +596,35 @@ class fpdb_db: + "database (including fpdb) and try again (%s)." \ % ( str(sys.exc_value).rstrip('\n'), ) return(1) - return(0) + 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: From 706ce46a9f06c71a7eaa52a21ed5f6941da5e1c0 Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 07:58:53 +0800 Subject: [PATCH 7/8] Boardcards for Hands table in new importer --- pyfpdb/Hand.py | 9 +++++++++ pyfpdb/fpdb_db.py | 2 ++ 2 files changed, 11 insertions(+) diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py index 6849a32c..38c3609b 100644 --- a/pyfpdb/Hand.py +++ b/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'""" diff --git a/pyfpdb/fpdb_db.py b/pyfpdb/fpdb_db.py index 201b98fd..29817af9 100644 --- a/pyfpdb/fpdb_db.py +++ b/pyfpdb/fpdb_db.py @@ -630,6 +630,7 @@ class fpdb_db: #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 @@ -640,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'] From 22ff98d7c9461c9e54351609574bbbc1b1e36723 Mon Sep 17 00:00:00 2001 From: Worros Date: Sat, 20 Jun 2009 14:02:03 +0800 Subject: [PATCH 8/8] Remove passthrough section from import_file_dict --- pyfpdb/fpdb_import.py | 50 +++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/pyfpdb/fpdb_import.py b/pyfpdb/fpdb_import.py index 99411573..455c1e27 100644 --- a/pyfpdb/fpdb_import.py +++ b/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 + + conv = None + # Load filter, process file, pass returned filename to import_fpdb_file - 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)) + 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)) - filter_name = filter.replace("ToFpdb", "") + filter_name = filter.replace("ToFpdb", "") - mod = __import__(filter) - obj = getattr(mod, filter_name, None) - if callable(obj): - conv = obj(in_path = file, out_path = out_path) - if(conv.getStatus()): - (stored, duplicates, partial, errors, ttime) = self.import_fpdb_file(out_path, site) - else: - # conversion didn't work - # TODO: appropriate response? - return (0, 0, 0, 1, 0) + mod = __import__(filter) + obj = getattr(mod, filter_name, None) + if callable(obj): + conv = obj(in_path = file, out_path = out_path) + if(conv.getStatus()): + (stored, duplicates, partial, errors, ttime) = self.import_fpdb_file(out_path, site) else: - print "Unknown filter filter_name:'%s' in filter:'%s'" %(filter_name, filter) - return + # conversion didn't work + # 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)