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

pyfpdb/Card.py

@@ -57,6 +57,21 @@ def fourStartCards(value1, suit1, value2, suit2, value3, suit3, value4, suit4):
         #AAKKs
         #AAKKr
         # Is probably what we are looking for
+
+        # mct:
+        # my maths says there are 4 classes of suitedness
+        # SSSS SSSx SSxy SSHH
+        # encode them as follows:
+        # SSSS (K, J, 6, 3)
+        # - 13C4 = 715 possibilities
+        # SSSx (K, J, 6),(3)
+        # - 13C3 * 13 = 3718 possibilities 
+        # SSxy (K, J),(6),(3)
+        # - 13C2 * 13*13 = 13182 possibilities
+        # SSHH (K, J),(6, 3)
+        # - 13C2 * 13C2 = 6084 possibilities
+        # Needless to say they won't fit on a 13x13 grid.
+        # The actual number of hands in each class is far greater
     return(0)
 
 def cardFromValueSuit(value, suit):
@@ -70,7 +85,7 @@ def cardFromValueSuit(value, suit):
 def valueSuitFromCard(card):
     """ Function to convert a card stored in the database (int 0-52) into value 
         and suit like 9s, 4c etc """
-    if card < 0 or card > 52:
+    if card < 0 or card > 52 or not card:
         return('')
     else:
         return( ['', '2h', '3h', '4h', '5h', '6h', '7h', '8h', '9h', 'Th', 'Jh', 'Qh', 'Kh', 'Ah'

pyfpdb/Hand.py

@@ -39,15 +39,14 @@ class Hand:
         self.starttime = 0
         self.handText = handText
         self.handid = 0
-        self.tablename = "Slartibartfast"
+        self.tablename = ""
-        self.hero = "Hiro"
+        self.hero = ""
         self.maxseats = 10
         self.counted_seats = 0
         self.buttonpos = 0
         self.seating = []
         self.players = []
         self.posted = []
-        self.involved = True
 
         # Collections indexed by street names
         self.bets = {}
@@ -55,23 +54,26 @@ class Hand:
         self.streets = {}
         self.actions = {} # [['mct','bets','$10'],['mika','folds'],['carlg','raises','$20']]
         self.board = {} # dict from street names to community cards
-        for street in self.streetList:
+        self.holecards = {}
+        for street in self.allStreets:
             self.streets[street] = "" # portions of the handText, filled by markStreets()
             self.bets[street] = {}
             self.lastBet[street] = 0
             self.actions[street] = []
             self.board[street] = []
+            self.holecards[street] = {} # dict from player names to holecards
         
         # Collections indexed by player names
-        self.holecards = {} # dict from player names to dicts by street ... of tuples ... of holecards
+#        self.holecards = {} # dict from player names to dicts by street ... of tuples ... of holecards
         self.discards = {} # dict from player names to dicts by street ... of tuples ... of discarded holecards
         self.stacks = {}
         self.collected = [] #list of ?
         self.collectees = {} # dict from player names to amounts collected (?)
 
         # Sets of players
-        self.shown = set()
         self.folded = set()
+        self.dealt = set()  # 'dealt to' line to be printed
+        self.shown = set()  # cards were shown
 
 #        self.action = []
         # Things to do with money
@@ -94,7 +96,7 @@ db: a connected fpdb_db object"""
         sqlids = db.getSqlPlayerIDs([p[1] for p in self.players], self.siteId)
         # HudCache data to come from DerivedStats class
         # HandsActions - all actions for all players for all streets - self.actions
-        # BoardCards - Skip - no longer necessary?
+        # BoardCards - Skip - no longer necessary
         # Hands - Summary information of hand indexed by handId - gameinfo
              #hh['siteHandNo'] =  self.handid
              # gametypeId SMALLINT UNSIGNED NOT NULL, FOREIGN KEY (gametypeId) REFERENCES Gametypes(id),
@@ -167,12 +169,10 @@ If a player has None chips he won't be added."""
         if chips is not None:
             self.players.append([seat, name, chips])
             self.stacks[name] = Decimal(chips)
-            self.holecards[name] = []
-            self.discards[name] = []
             self.pot.addPlayer(name)
-            for street in self.streetList:
+            for street in self.allStreets:
                 self.bets[street][name] = []
-                self.holecards[name] = {} # dict from street names.
+                #self.holecards[name] = {} # dict from street names.
                 self.discards[name] = {} # dict from street names.
 
 
@@ -411,32 +411,32 @@ Map the tuple self.gametype onto the pokerstars string describing it
     def printHand(self):
         self.writeHand(sys.stdout)
 
-    def printActionLine(self, act, fh):
+    def actionString(self, act):
         if act[1] == 'folds':
-            print >>fh, ("%s: folds " %(act[0]))
+            return ("%s: folds " %(act[0]))
         elif act[1] == 'checks':
-            print >>fh, ("%s: checks " %(act[0]))
+            return ("%s: checks " %(act[0]))
         elif act[1] == 'calls':
-            print >>fh, ("%s: calls $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
+            return ("%s: calls $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
         elif act[1] == 'bets':
-            print >>fh, ("%s: bets $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
+            return ("%s: bets $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
         elif act[1] == 'raises':
-            print >>fh, ("%s: raises $%s to $%s%s" %(act[0], act[2], act[3], ' and is all-in' if act[5] else ''))
+            return ("%s: raises $%s to $%s%s" %(act[0], act[2], act[3], ' and is all-in' if act[5] else ''))
         elif act[1] == 'completea':
-            print >>fh, ("%s: completes to $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
+            return ("%s: completes to $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
         elif act[1] == 'posts':
             if(act[2] == "small blind"):
-                print >>fh, ("%s: posts small blind $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
+                return ("%s: posts small blind $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
             elif(act[2] == "big blind"):
-                print >>fh, ("%s: posts big blind $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
+                return ("%s: posts big blind $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
             elif(act[2] == "both"):
-                print >>fh, ("%s: posts small & big blinds $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
+                return ("%s: posts small & big blinds $%s%s" %(act[0], act[3], ' and is all-in' if act[4] else ''))
         elif act[1] == 'bringin':
-            print >>fh, ("%s: brings in for $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
+            return ("%s: brings in for $%s%s" %(act[0], act[2], ' and is all-in' if act[3] else ''))
         elif act[1] == 'discards':
-            print >>fh, ("%s: discards %s %s%s" %(act[0], act[2], 'card' if act[2] == 1 else 'cards' , " [" + " ".join(self.discards[act[0]]['DRAWONE']) + "]" if self.hero == act[0] else ''))
+            return ("%s: discards %s %s%s" %(act[0], act[2], 'card' if act[2] == 1 else 'cards' , " [" + " ".join(self.discards[act[0]]['DRAWONE']) + "]" if self.hero == act[0] else ''))
         elif act[1] == 'stands pat':
-            print >>fh, ("%s: stands pat" %(act[0]))
+            return ("%s: stands pat" %(act[0]))
 
 
 class HoldemOmahaHand(Hand):
@@ -444,9 +444,10 @@ class HoldemOmahaHand(Hand):
         if gametype['base'] != 'hold':
             pass # or indeed don't pass and complain instead
         logging.debug("HoldemOmahaHand")
-        self.streetList = ['BLINDSANTES', 'DEAL', 'PREFLOP','FLOP','TURN','RIVER'] # a list of the observed street names in order
+        self.allStreets = ['BLINDSANTES', 'PREFLOP','FLOP','TURN','RIVER']
+        self.holeStreets = ['PREFLOP']
         self.communityStreets = ['FLOP', 'TURN', 'RIVER']
-        self.actionStreets = ['PREFLOP','FLOP','TURN','RIVER']
+        self.actionStreets = ['BLINDSANTES','PREFLOP','FLOP','TURN','RIVER']
         Hand.__init__(self, sitename, gametype, handText, builtFrom = "HHC")
         self.sb = gametype['sb']
         self.bb = gametype['bb']
@@ -484,24 +485,32 @@ class HoldemOmahaHand(Hand):
             pass
                 
 
-    def addHoleCards(self, cards, player, shown=False):
+    def addHoleCards(self, cards, player, shown=False, dealt=False):
         """\
 Assigns observed holecards to a player.
 cards   list of card bigrams e.g. ['2h','Jc']
 player  (string) name of player
+shown   whether they were revealed at showdown
+dealt   whether they were seen in a 'dealt to' line
 """
         logging.debug("addHoleCards %s %s" % (cards, player))
         try:
             self.checkPlayerExists(player)
-            cardset = set(self.card(c) for c in cards)
-            if shown and len(cardset) > 0:
-                self.shown.add(player)
-            if 'PREFLOP' in self.holecards[player]:
-                self.holecards[player]['PREFLOP'].update(cardset)
-            else:
-                self.holecards[player]['PREFLOP'] = cardset
         except FpdbParseError, e:
             print "[ERROR] Tried to add holecards for unknown player: %s" % (player,)
+            return
+
+        cardset = set((self.card(c) for c in cards))
+        if len(cardset) == 0:
+            return
+        if dealt:
+            self.dealt.add(player)
+        if shown:
+            self.shown.add(player)
+        if player in self.holecards['PREFLOP']:
+            self.holecards['PREFLOP'][player].update(cardset)
+        else:
+            self.holecards['PREFLOP'][player] = cardset
 
     def addShownCards(self, cards, player, holeandboard=None):
         """\
@@ -510,14 +519,108 @@ Card ranks will be uppercased
 """
         logging.debug("addShownCards %s hole=%s all=%s" % (player, cards,  holeandboard))
         if cards is not None:
-            self.shown.add(player)
+            self.addHoleCards(cards,player,shown=True)
-            self.addHoleCards(cards,player)
         elif holeandboard is not None:
             holeandboard = set([self.card(c) for c in holeandboard])
             board = set([c for s in self.board.values() for c in s])
             self.addHoleCards(holeandboard.difference(board),player,shown=True)
 
 
+    def writeHTMLHand(self, fh=sys.__stdout__):
+        from nevow import tags as T
+        from nevow import flat
+        players_who_act_preflop = (([x[0] for x in self.actions['PREFLOP']]+[x[0] for x in self.actions['BLINDSANTES']]))
+        players_stacks = [x for x in self.players if x[1] in players_who_act_preflop]
+        action_streets = [x for x in self.actionStreets if len(self.actions[x]) > 0]
+        def render_stack(context,data):
+            pat = context.tag.patternGenerator('list_item')
+            for player in data:
+                x = "Seat %s: %s ($%s in chips) " %(player[0], player[1],
+                player[2])
+                context.tag[ pat().fillSlots('playerStack', x)]
+            return context.tag
+
+        def render_street(context,data):
+            pat = context.tag.patternGenerator('list_item')
+            for street in data:
+                lines = []
+                if street in self.holeStreets and self.holecards[street]:
+                     lines.append(
+                        T.ol(class_='dealclosed', data=street,
+                        render=render_deal) [
+                            T.li(pattern='list_item')[ T.slot(name='deal') ]
+                        ]
+                    )
+                if street in self.communityStreets and self.board[street]:
+                    lines.append(
+                        T.ol(class_='community', data=street,
+                        render=render_deal_community)[
+                            T.li(pattern='list_item')[ T.slot(name='deal') ]
+                        ]
+                    )
+                if street in self.actionStreets and self.actions[street]:
+                    lines.append( 
+                        T.ol(class_='actions', data=self.actions[street], render=render_action) [
+                            T.li(pattern='list_item')[ T.slot(name='action') ]
+                        ]
+                    )
+                if lines:
+                    context.tag[ pat().fillSlots('street', [ T.h3[ street ] ]+lines)]
+            return context.tag
+
+        def render_deal(context,data):
+            # data is streetname
+# we can have open+closed, or just open, or just closed.
+
+            if self.holecards[data]:
+                for player in self.holecards[data]:
+                    somestuff = 'dealt to %s %s' % (player, self.holecards[data][player])
+                    pat = context.tag.patternGenerator('list_item')
+                    context.tag[ pat().fillSlots('deal', somestuff)]
+            return context.tag
+
+        def render_deal_community(context,data):
+            # data is streetname
+            if self.board[data]:
+                somestuff = '[' + ' '.join(self.board[data]) + ']'
+                pat = context.tag.patternGenerator('list_item')
+                context.tag[ pat().fillSlots('deal', somestuff)]
+            return context.tag
+        def render_action(context,data):
+            pat = context.tag.patternGenerator('list_item')
+            for act in data:
+                x = self.actionString(act)
+                context.tag[ pat().fillSlots('action', x)]
+            return context.tag
+
+        s = T.p[ 
+            T.h1[ 
+                T.span(class_='site')["%s Game #%s]" % ('PokerStars', self.handid)],
+                T.span(class_='type_limit')[ "%s ($%s/$%s)" %(self.getGameTypeAsString(), self.sb, self.bb) ],
+                T.span(class_='date')[ datetime.datetime.strftime(self.starttime,'%Y/%m/%d - %H:%M:%S ET') ]
+            ],
+            T.h2[ "Table '%s' %d-max Seat #%s is the button" %(self.tablename,
+            self.maxseats, self.buttonpos)],
+            T.ol(class_='stacks', data = players_stacks, render=render_stack)[
+                T.li(pattern='list_item')[ T.slot(name='playerStack') ]
+            ],
+            T.ol(class_='streets', data = self.allStreets,
+            render=render_street)[
+                T.li(pattern='list_item')[ T.slot(name='street')]
+            ]
+        ]
+        import tidy
+
+        options = dict(input_xml=True,
+                   output_xhtml=True,
+                   add_xml_decl=False,
+                   doctype='omit',
+                   indent='auto',
+                   tidy_mark=False)
+
+        return str(tidy.parseString(flat.flatten(s), **options))
+
+        
     def writeHand(self, fh=sys.__stdout__):
         # PokerStars format.
         print >>fh, ("%s Game #%s:  %s ($%s/$%s) - %s" %("PokerStars", self.handid, self.getGameTypeAsString(), self.sb, self.bb, datetime.datetime.strftime(self.starttime,'%Y/%m/%d - %H:%M:%S ET')))
@@ -531,33 +634,36 @@ Card ranks will be uppercased
 
         if self.actions['BLINDSANTES']:
             for act in self.actions['BLINDSANTES']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
         
         print >>fh, ("*** HOLE CARDS ***")
-        if self.involved:
+        for player in self.dealt:
-            print >>fh, ("Dealt to %s [%s]" %(self.hero , " ".join(self.holecards[self.hero]['PREFLOP'])))
+            print >>fh, ("Dealt to %s [%s]" %(player, " ".join(self.holecards['PREFLOP'][player])))
+        if self.hero == "":
+            for player in self.shown.difference(self.dealt):
+                print >>fh, ("Dealt to %s [%s]" %(player, " ".join(self.holecards['PREFLOP'][player])))
 
         if self.actions['PREFLOP']:
             for act in self.actions['PREFLOP']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if self.board['FLOP']:
             print >>fh, ("*** FLOP *** [%s]" %( " ".join(self.board['FLOP'])))
         if self.actions['FLOP']:
             for act in self.actions['FLOP']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if self.board['TURN']:
             print >>fh, ("*** TURN *** [%s] [%s]" %( " ".join(self.board['FLOP']), " ".join(self.board['TURN'])))
         if self.actions['TURN']:
             for act in self.actions['TURN']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if self.board['RIVER']:
             print >>fh, ("*** RIVER *** [%s] [%s]" %(" ".join(self.board['FLOP']+self.board['TURN']), " ".join(self.board['RIVER']) ))
         if self.actions['RIVER']:
             for act in self.actions['RIVER']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
 
         #Some sites don't have a showdown section so we have to figure out if there should be one
@@ -573,8 +679,8 @@ Card ranks will be uppercased
                     numOfHoleCardsNeeded = 4
                 elif self.gametype['category'] in ('holdem'):
                     numOfHoleCardsNeeded = 2
-                if len(self.holecards[name]['PREFLOP']) == numOfHoleCardsNeeded:
+                if len(self.holecards['PREFLOP'][name]) == numOfHoleCardsNeeded:
-                    print >>fh, ("%s shows [%s] (a hand...)" % (name, " ".join(self.holecards[name]['PREFLOP'])))
+                    print >>fh, ("%s shows [%s] (a hand...)" % (name, " ".join(self.holecards['PREFLOP'][name])))
                 
         # Current PS format has the lines:
         # Uncalled bet ($111.25) returned to s0rrow
@@ -743,12 +849,12 @@ Card ranks will be uppercased
                     (nc,oc) = self.holecards[player]['DEAL']
                     print >>fh, _("Dealt to %s: [%s]") % (player, " ".join(nc))
             for act in self.actions['DEAL']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if 'DRAWONE' in self.actions:
             print >>fh, _("*** FIRST DRAW ***")
             for act in self.actions['DRAWONE']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
                 if act[0] == self.hero and act[1] == 'discards':
                     (nc,oc) = self.holecards[act[0]]['DRAWONE']
                     dc = self.discards[act[0]]['DRAWONE']
@@ -758,7 +864,7 @@ Card ranks will be uppercased
         if 'DRAWTWO' in self.actions:
             print >>fh, _("*** SECOND DRAW ***")
             for act in self.actions['DRAWTWO']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
                 if act[0] == self.hero and act[1] == 'discards':
                     (nc,oc) = self.holecards[act[0]]['DRAWTWO']
                     dc = self.discards[act[0]]['DRAWTWO']
@@ -768,7 +874,7 @@ Card ranks will be uppercased
         if 'DRAWTHREE' in self.actions:
             print >>fh, _("*** THIRD DRAW ***")
             for act in self.actions['DRAWTHREE']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
                 if act[0] == self.hero and act[1] == 'discards':
                     (nc,oc) = self.holecards[act[0]]['DRAWTHREE']
                     dc = self.discards[act[0]]['DRAWTHREE']
@@ -908,7 +1014,7 @@ Add a complete on [street] by [player] to [amountTo]
                     print >>fh, _("Dealt to %s:%s%s") % (player, " [" + " ".join(closed) + "] " if closed else " ", "[" + " ".join(open) + "]" if open else "")
             for act in self.actions['THIRD']:
                 #FIXME: Need some logic here for bringin vs completes
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if 'FOURTH' in self.actions:
             dealt = 0
@@ -925,7 +1031,7 @@ Add a complete on [street] by [player] to [amountTo]
                         print >>fh, _("*** 4TH STREET ***")
                     print >>fh, _("Dealt to %s:%s%s") % (player, " [" + " ".join(old) + "] " if old else " ", "[" + " ".join(new) + "]" if new else "")
             for act in self.actions['FOURTH']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if 'FIFTH' in self.actions:
             dealt = 0
@@ -943,7 +1049,7 @@ Add a complete on [street] by [player] to [amountTo]
                         print >>fh, _("*** 5TH STREET ***")
                     print >>fh, _("Dealt to %s:%s%s") % (player, " [" + " ".join(old) + "] " if old else " ", "[" + " ".join(new) + "]" if new else "")
             for act in self.actions['FIFTH']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if 'SIXTH' in self.actions:
             dealt = 0
@@ -961,7 +1067,7 @@ Add a complete on [street] by [player] to [amountTo]
                         print >>fh, _("*** 6TH STREET ***")
                     print >>fh, _("Dealt to %s:%s%s") % (player, " [" + " ".join(old) + "] " if old else " ", "[" + " ".join(new) + "]" if new else "")
             for act in self.actions['SIXTH']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         if 'SEVENTH' in self.actions:
             # OK. It's possible that they're all in at an earlier street, but only closed cards are dealt.
@@ -980,7 +1086,7 @@ Add a complete on [street] by [player] to [amountTo]
                     if new:
                         print >>fh, _("Dealt to %s:%s%s") % (player, " [" + " ".join(old) + "] " if old else " ", "[" + " ".join(new) + "]" if new else "")
             for act in self.actions['SEVENTH']:
-                self.printActionLine(act, fh)
+                print >>fh, self.actionString(act)
 
         #Some sites don't have a showdown section so we have to figure out if there should be one
         # The logic for a showdown is: at the end of river action there are at least two players in the hand
@@ -1111,7 +1217,8 @@ class Pot(object):
 def assemble(cnxn, handid):
     c = cnxn.cursor()
     
-    # We need the following for the Hand.__init__
+    # We need at least sitename, gametype, handid
+    # for the Hand.__init__
     c.execute("""
 select
     s.name,
@@ -1120,27 +1227,24 @@ select
     g.type,
     g.limitType,
     g.hilo,
-    g.smallBlind / 100.0,
+    round(g.smallBlind / 100.0,2),
-    g.bigBlind / 100.0 ,
+    round(g.bigBlind / 100.0,2),
-    g.smallBet / 100.0,
+    round(g.smallBet / 100.0,2),
-    g.bigBet / 100.0,
+    round(g.bigBet / 100.0,2),
     s.currency,
-    bc.card1value,
+    h.boardcard1,
-    bc.card1suit,
+    h.boardcard2,
-    bc.card2value,bc.card2suit,
+    h.boardcard3,
-    bc.card3value,bc.card3suit,
+    h.boardcard4,
-    bc.card4value,bc.card4suit,
+    h.boardcard5
-    bc.card5value,bc.card5suit
 from
     hands as h,
-    boardcards as bc,
     sites as s,
     gametypes as g,
     handsplayers as hp,
     players as p
 where
     h.id = %(handid)s
-and bc.handid = h.id
 and g.id = h.gametypeid
 and hp.handid = h.id
 and p.id = hp.playerid
@@ -1150,20 +1254,15 @@ limit 1""", {'handid':handid})
     res = c.fetchone()
     gametype = {'category':res[1],'base':res[2],'type':res[3],'limitType':res[4],'hilo':res[5],'sb':res[6],'bb':res[7], 'currency':res[10]}
     h = HoldemOmahaHand(hhc = None, sitename=res[0], gametype = gametype, handText=None, builtFrom = "DB", handid=handid)
-    cards = map("".join, zip(map(str,res[11:21:2]), res[12:21:2]))
+    cards = map(Card.valueSuitFromCard, res[11:16] )
-    
+    if cards[0]:
-    if cards[0] != "0x":
         h.setCommunityCards('FLOP', cards[0:3])
-    if cards[3] != "0x":
+    if cards[3]:
-        h.setCommunityCards('TURN', cards[3])
+        h.setCommunityCards('TURN', [cards[3]])
-    if cards[4] != "0x":      
+    if cards[4]:      
-        h.setCommunityCards('RIVER', cards[4])
+        h.setCommunityCards('RIVER', [cards[4]])
     #[Card.valueSuitFromCard(x) for x in cards]
     
-    
-    #TODO : doesn't look like this is in the database; don't like the way Hand requires it
-    h.hero = 'mcturnbull'
-    
     # HandInfo : HID, TABLE
     # BUTTON - why is this treated specially in Hand?
     # answer: it is written out in hand histories
@@ -1186,9 +1285,11 @@ WHERE h.id = %(handid)s
     c.execute("""
 SELECT
     hp.seatno,
+    round(hp.winnings / 100.0,2) as winnings,
     p.name,
     round(hp.startcash / 100.0,2) as chips,
-    (hp.card1,hp.card2) as hole
+    hp.card1,hp.card2,
+    hp.position
 FROM
     handsplayers as hp,
     players as p
@@ -1196,10 +1297,16 @@ WHERE
     hp.handid = %(handid)s
 and p.id = hp.playerid
 """, {'handid':handid})
-    for (seat, name, chips, cards) in c.fetchall():
+    for (seat, winnings, name, chips, card1,card2, position) in c.fetchall():
         h.addPlayer(seat,name,chips)
-        h.addHoleCards([Card.valueSuitFromCard(x) for x in cards],name)
+        if card1 and card2:
+            h.addHoleCards(map(Card.valueSuitFromCard, (card1,card2)), name, dealt=True)
+        if winnings > 0:
+            h.addCollectPot(name, winnings)
+        if position == 'B':
+            h.buttonpos = seat
     
+
     # actions
     c.execute("""
 SELECT
@@ -1208,7 +1315,7 @@ SELECT
     ha.street,
     ha.action,
     ha.allin,
-    ha.amount / 100.0
+    round(ha.amount / 100.0,2)
 FROM
     handsplayers as hp,
     handsactions as ha,
@@ -1223,7 +1330,7 @@ ORDER BY
     res = c.fetchall()
     for (actnum,player, streetnum, act, allin, amount) in res:
         act=act.strip()
-        street = h.streetList[streetnum+2]
+        street = h.allStreets[streetnum+1]
         if act==u'blind':
             h.addBlind(player, 'big blind', amount)
             # TODO: The type of blind is not recorded in the DB.
@@ -1241,7 +1348,7 @@ ORDER BY
         else:
             print act, player, streetnum, allin, amount
             # TODO : other actions
-    #hhc.readCollectPot(self)
+
     #hhc.readShowdownActions(self)
     #hc.readShownCards(self)
     h.totalPot()

pyfpdb/PokerStarsToFpdb.py

@@ -209,7 +209,7 @@ follow :  whether to tail -f the input"""
         for a in self.re_PostBB.finditer(hand.handText):
             hand.addBlind(a.group('PNAME'), 'big blind', a.group('BB'))
         for a in self.re_PostBoth.finditer(hand.handText):
-            hand.addBlind(a.group('PNAME'), 'small & big blinds', a.group('SBBB'))
+            hand.addBlind(a.group('PNAME'), 'both', a.group('SBBB'))
 
     def readHeroCards(self, hand):
         m = self.re_HeroCards.search(hand.handText)

pyfpdb/fpdb_save_to_db.py

@@ -85,7 +85,8 @@ def ring_holdem_omaha(config, settings, db, cursor, base, category, site_hand_no
     t2 = time()
 
     hands_id = fpdb_simple.storeHands(backend, db, cursor, site_hand_no, gametype_id
-                                   ,hand_start_time, names, tableName, maxSeats, hudImportData)
+                                   ,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

pyfpdb/fpdb_simple.py

@@ -1147,10 +1147,13 @@ card5Value, card5Suit) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""",
 #end def store_board_cards
  
 def storeHands(backend, conn, cursor, site_hand_no, gametype_id
-              ,hand_start_time, names, tableName, maxSeats, hudCache):
+              ,hand_start_time, names, tableName, maxSeats, hudCache,
+              board_values, board_suits):
+    cards = [Card.cardFromValueSuit(v,s) for v,s in zip(board_values,board_suits)]
 #stores into table hands:
     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
@@ -1159,9 +1162,11 @@ def storeHands(backend, conn, cursor, site_hand_no, gametype_id
                        ,showdownPot
                        ) 
                        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)
                     """
                    ,   (site_hand_no, gametype_id, hand_start_time, len(names), tableName, datetime.datetime.today(), maxSeats
+                       ,cards[0], cards[1], cards[2], cards[3], cards[4]
                        ,hudCache['playersVpi'], hudCache['playersAtStreet1'], hudCache['playersAtStreet2']
                        ,hudCache['playersAtStreet3'], hudCache['playersAtStreet4'], hudCache['playersAtShowdown']
                        ,hudCache['street0Raises'], hudCache['street1Raises'], hudCache['street2Raises']