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

pyfpdb/Database.py

@@ -427,7 +427,8 @@ class Database:
             print "***Error: "+err[2]+"("+str(err[1])+"): "+str(sys.exc_info()[1])
 
     def get_stats_from_hand( self, hand, type   # type is "ring" or "tour"
-                           , hud_params = {'aggregate_tour':False, 'aggregate_ring':False, 'hud_style':'A', 'agg_bb_mult':100}
+                           , hud_params = {'aggregate_tour':False, 'aggregate_ring':False, 'hud_style':'A', 'hud_days':30, 'agg_bb_mult':100
+                                          ,'h_aggregate_tour':False, 'h_aggregate_ring':False, 'h_hud_style':'S', 'h_hud_days':30, 'h_agg_bb_mult':100}
                            , hero_id = -1
                            ):
         aggregate   = hud_params['aggregate_tour'] if type == "tour" else hud_params['aggregate_ring']

pyfpdb/GuiGraphViewer.py

@@ -97,34 +97,6 @@ class GuiGraphViewer (threading.Thread):
 
         self.db.rollback()
 
-#################################
-#
-#        self.db.cursor.execute("""select UNIX_TIMESTAMP(handStart) as time, id from Hands ORDER BY time""")
-#        THRESHOLD = 1800
-#        hands = self.db.cursor.fetchall()
-#
-#        times = map(lambda x:long(x[0]), hands)
-#        handids = map(lambda x:int(x[1]), hands)
-#        print "DEBUG: len(times) %s" %(len(times))
-#        diffs = diff(times)
-#        print "DEBUG: len(diffs) %s" %(len(diffs))
-#        index = nonzero(diff(times) > THRESHOLD)
-#        print "DEBUG: len(index[0]) %s" %(len(index[0]))
-#        print "DEBUG: index %s" %(index)
-#        print "DEBUG: index[0][0] %s" %(index[0][0])
-#
-#        total = 0
-#
-#        last_idx = 0
-#        for i in range(len(index[0])):
-#            print "Hands in session %4s: %4s  Start: %s End: %s Total: %s" %(i, index[0][i] - last_idx, strftime("%d/%m/%Y %H:%M", localtime(times[last_idx])), strftime("%d/%m/%Y %H:%M", localtime(times[index[0][i]])), times[index[0][i]] - times[last_idx])
-#            total = total + (index[0][i] - last_idx)
-#            last_idx = index[0][i] + 1
-#
-#        print "Total: ", total
-#################################
-
-
     def get_vbox(self):
         """returns the vbox of this thread"""
         return self.mainHBox

pyfpdb/GuiPlayerStats.py

@@ -248,7 +248,7 @@ class GuiPlayerStats (threading.Thread):
             cell.set_property('text', str)
             cell.set_property('foreground', 'red')
         else:
-            cell.set_property('foreground', 'green')
+            cell.set_property('foreground', 'darkgreen')
 
         return
 

pyfpdb/GuiSessionViewer.py

@@ -21,9 +21,17 @@ import pygtk
 pygtk.require('2.0')
 import gtk
 import os
+import traceback
 from time import time, strftime, localtime
 try:
-    from numpy import diff, nonzero, sum
+    import matplotlib
+    matplotlib.use('GTK')
+    from matplotlib.figure import Figure
+    from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
+    from matplotlib.backends.backend_gtkagg import NavigationToolbar2GTKAgg as NavigationToolbar
+    from matplotlib.finance import candlestick2
+
+    from numpy import diff, nonzero, sum, cumsum, max, mina
 #    from matplotlib.dates import  DateFormatter, WeekdayLocator, HourLocator, \
 #     DayLocator, MONDAY, timezone
 
@@ -49,6 +57,11 @@ class GuiSessionViewer (threading.Thread):
         self.PGSQL          = 3
         self.SQLITE         = 4
 
+        self.fig = None
+        self.canvas = None
+        self.ax = None
+        self.graphBox = None
+        
         # create new db connection to avoid conflicts with other threads
         self.db = Database.Database(self.conf, sql=self.sql)
         self.cursor = self.db.cursor
@@ -66,17 +79,17 @@ class GuiSessionViewer (threading.Thread):
         filters_display = { "Heroes"    : True,
                             "Sites"     : True,
                             "Games"     : False,
-                            "Limits"    : True,
+                            "Limits"    : False,
-                            "LimitSep"  : True,
+                            "LimitSep"  : False,
-                            "LimitType" : True,
+                            "LimitType" : False,
                             "Type"      : True,
-                            "Seats"     : True,
+                            "Seats"     : False,
-                            "SeatSep"   : True,
+                            "SeatSep"   : False,
                             "Dates"     : True,
-                            "Groups"    : True,
+                            "Groups"    : False,
-                            "GroupsAll" : True,
+                            "GroupsAll" : False,
                             "Button1"   : True,
-                            "Button2"   : True
+                            "Button2"   : False
                           }
 
         self.filters = Filters.Filters(self.db, self.conf, self.sql, display = filters_display)
@@ -142,29 +155,6 @@ class GuiSessionViewer (threading.Thread):
         """returns the vbox of this thread"""
         return self.main_hbox
 
-    def generateGraph(self):
-        fig = figure()
-        fig.subplots_adjust(bottom=0.2)
-        ax = fig.add_subplot(111)
-        ax.xaxis.set_major_locator(mondays)
-        ax.xaxis.set_minor_locator(alldays)
-        ax.xaxis.set_major_formatter(weekFormatter)
-        #ax.xaxis.set_minor_formatter(dayFormatter)
-        #plot_day_summary(ax, quotes, ticksize=3)
-#        candlestick(ax, quotes, width=0.6)
-#        candlestick2(ax, opens, closes, highs, lows, width=4, colorup='k', colordown='r', alpha=0.75)
-#    Represent the open, close as a bar line and high low range as a vertical line.
-#    ax          : an Axes instance to plot to
-#    width       : the bar width in points
-#    colorup     : the color of the lines where close >= open
-#    colordown   : the color of the lines where close <  open
-#    alpha       : bar transparency
-#    return value is lineCollection, barCollection
-        ax.xaxis_date()
-        ax.autoscale_view()
-        setp( gca().get_xticklabels(), rotation=45, horizontalalignment='right')
-
-        show()
 
 
     def refreshStats(self, widget, data):
@@ -204,17 +194,20 @@ class GuiSessionViewer (threading.Thread):
             print "No limits found"
             return
 
-        self.createStatsTable(vbox, playerids, sitenos, limits, seats)
+        self.createStatsPane(vbox, playerids, sitenos, limits, seats)
 
-    def createStatsTable(self, vbox, playerids, sitenos, limits, seats):
+    def createStatsPane(self, vbox, playerids, sitenos, limits, seats):
         starttime = time()
 
-        # Display summary table at top of page
+        (results, opens, closes, highs, lows) = self.generateDatasets(playerids, sitenos, limits, seats)
-        # 3rd parameter passes extra flags, currently includes:
-        # holecards - whether to display card breakdown (True/False)
-        flags = [False]
-        self.addTable(vbox, 'playerDetailedStats', flags, playerids, sitenos, limits, seats)
 
+
+
+        self.graphBox = gtk.VBox(False, 0)
+        self.graphBox.show()
+        self.generateGraph(opens, closes, highs, lows)
+
+        vbox.pack_start(self.graphBox)
         # Separator
         sep = gtk.HSeparator()
         vbox.pack_start(sep, expand=False, padding=3)
@@ -234,25 +227,155 @@ class GuiSessionViewer (threading.Thread):
         vbox1.show()
         swin.add_with_viewport(vbox1)
 
-        # Detailed table
+        self.addTable(vbox1, results)
-        flags = [True]
-        self.addTable(vbox1, 'playerDetailedStats', flags, playerids, sitenos, limits, seats)
 
         self.db.rollback()
         print "Stats page displayed in %4.2f seconds" % (time() - starttime)
     #end def fillStatsFrame(self, vbox):
 
-    def addTable(self, vbox, query, flags, playerids, sitenos, limits, seats):
+    def generateDatasets(self, playerids, sitenos, limits, seats):
+        # Get a list of all handids and their timestampts
+        # FIXME: Will probably want to be able to filter this list eventually
+        # FIXME: Join on handsplayers for Hero to get other useful stuff like total profit?
+
+
+        # Postgres version requires - EXTRACT(epoch from h.handStart)
+        q = """
+select UNIX_TIMESTAMP(h.handStart) as time, hp.handId, hp.startCash, hp.winnings, hp.totalProfit
+from HandsPlayers hp
+     inner join Hands h       on  (h.id = hp.handId)
+     inner join Gametypes gt  on  (gt.Id = h.gameTypeId)
+     inner join Sites s       on  (s.Id = gt.siteId)
+     inner join Players p     on  (p.Id = hp.playerId)
+where hp.playerId in <player_test>
+and   date_format(h.handStart, '%Y-%m-%d') <datestest>
+order by time
+"""
+        start_date, end_date = self.filters.getDates()
+        q = q.replace("<datestest>", " between '" + start_date + "' and '" + end_date + "'")
+
+        nametest = str(tuple(playerids))
+        nametest = nametest.replace("L", "")
+        nametest = nametest.replace(",)",")")
+        q = q.replace("<player_test>", nametest)
+        self.db.cursor.execute(q)
+        THRESHOLD = 1800
+        hands = self.db.cursor.fetchall()
+
+        # Take that list and create an array of the time between hands
+        times = map(lambda x:long(x[0]), hands)
+        handids = map(lambda x:int(x[1]), hands)
+        winnings = map(lambda x:float(x[4]), hands)
+        print "DEBUG: len(times) %s" %(len(times))
+        diffs = diff(times) # This array is the difference in starttime between consecutive hands
+        index = nonzero(diff(times) > THRESHOLD) # This array represents the indexes into 'times' for start/end times of sessions
+                                                 # ie. times[index[0][0]] is the end of the first session
+        #print "DEBUG: len(index[0]) %s" %(len(index[0]))
+        #print "DEBUG: index %s" %(index)
+        #print "DEBUG: index[0][0] %s" %(index[0][0])
+
+        total = 0
+        last_idx = 0
+        lowidx = 0
+        uppidx = 0
+        opens = []
+        closes = []
+        highs = []
+        lows = []
+        results = []
+        cum_sum = cumsum(winnings)
+        cum_sum = cum_sum/100
+        # Take all results and format them into a list for feeding into gui model.
+        for i in range(len(index[0])):
+            sid = i                                                             # Session id
+            hds = index[0][i] - last_idx                                        # Number of hands in session
+            if hds > 0:
+                stime = strftime("%d/%m/%Y %H:%M", localtime(times[last_idx]))      # Formatted start time
+                etime = strftime("%d/%m/%Y %H:%M", localtime(times[index[0][i]]))   # Formatted end time
+                hph = (times[index[0][i]] - times[last_idx])/60                     # Hands per hour
+                won = sum(winnings[last_idx:index[0][i]])/100.0
+                hwm = max(cum_sum[last_idx:index[0][i]])
+                lwm = min(cum_sum[last_idx:index[0][i]])
+                #print "DEBUG: range: (%s, %s) - (min, max): (%s, %s)" %(last_idx, index[0][i], hwm, lwm)
+            
+                results.append([sid, hds, stime, etime, hph, won])
+                opens.append((sum(winnings[:last_idx]))/100)
+                closes.append((sum(winnings[:index[0][i]]))/100)
+                highs.append(hwm)
+                lows.append(lwm)
+                #print "Hands in session %4s: %4s  Start: %s End: %s HPH: %s Profit: %s" %(sid, hds, stime, etime, hph, won)
+                total = total + (index[0][i] - last_idx)
+                last_idx = index[0][i] + 1
+
+        return (results, opens, closes, highs, lows)
+
+    def clearGraphData(self):
+
+        try:
+            try:
+                if self.canvas:
+                    self.graphBox.remove(self.canvas)
+            except:
+                pass
+
+            if self.fig != None:
+                self.fig.clear()
+            self.fig = Figure(figsize=(5,4), dpi=100)
+            if self.canvas is not None:
+                self.canvas.destroy()
+
+            self.canvas = FigureCanvas(self.fig)  # a gtk.DrawingArea
+        except:
+            err = traceback.extract_tb(sys.exc_info()[2])[-1]
+            print "***Error: "+err[2]+"("+str(err[1])+"): "+str(sys.exc_info()[1])
+            raise
+
+
+    def generateGraph(self, opens, closes, highs, lows):
+        self.clearGraphData()
+
+        #FIXME: Weird - first data entry is crashing this for me
+        opens = opens[1:]
+        closes = closes[1:]
+        highs = highs[1:]
+        lows = lows[1:]
+#        print "DEBUG:"
+#        print "highs = %s" % highs
+#        print "lows = %s" % lows
+#        print "opens = %s" % opens
+#        print "closes = %s" % closes
+#        print "len(highs): %s == len(lows): %s" %(len(highs), len(lows))
+#        print "len(opens): %s == len(closes): %s" %(len(opens), len(closes))
+#
+#        for i in range(len(highs)):
+#            print "DEBUG: (%s, %s, %s, %s)" %(lows[i], opens[i], closes[i], highs[i])
+#            print "DEBUG: diffs h/l: %s o/c: %s" %(lows[i] - highs[i], opens[i] - closes[i])
+
+        self.ax = self.fig.add_subplot(111)
+
+        self.ax.set_title("Session candlestick graph")
+
+        #Set axis labels and grid overlay properites
+        self.ax.set_xlabel("Sessions", fontsize = 12)
+        self.ax.set_ylabel("$", fontsize = 12)
+        self.ax.grid(color='g', linestyle=':', linewidth=0.2)
+
+        candlestick2(self.ax, opens, closes, highs, lows, width=0.50, colordown='r', colorup='g', alpha=1.00)
+        self.graphBox.add(self.canvas)
+        self.canvas.show()
+        self.canvas.draw()
+
+    def addTable(self, vbox, results):
         row = 0
         sqlrow = 0
         colalias,colshow,colheading,colxalign,colformat = 0,1,2,3,4
-        if not flags:  holecards = False
-        else:          holecards = flags[0]
 
         # pre-fetch some constant values:
         cols_to_show = [x for x in self.columns if x[colshow]]
 
         self.liststore = gtk.ListStore(*([str] * len(cols_to_show)))
+        for row in results:
+            iter = self.liststore.append(row)
 
         view = gtk.TreeView(model=self.liststore)
         view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
@@ -282,58 +405,6 @@ class GuiSessionViewer (threading.Thread):
                 listcols[col].add_attribute(numcell, 'text', col)
                 listcols[col].set_expand(True)
 
-        # Get a list of all handids and their timestampts
-        # FIXME: Will probably want to be able to filter this list eventually
-        # FIXME: Join on handsplayers for Hero to get other useful stuff like total profit?
-        q = """
-select UNIX_TIMESTAMP(h.handStart) as time, hp.handId, hp.startCash, hp.winnings, hp.totalProfit
-from HandsPlayers hp
-     inner join Hands h       on  (h.id = hp.handId)
-     inner join Gametypes gt  on  (gt.Id = h.gameTypeId)
-     inner join Sites s       on  (s.Id = gt.siteId)
-     inner join Players p     on  (p.Id = hp.playerId)
-where hp.playerId in (2)
-order by time
-"""
-        self.db.cursor.execute(q)
-        THRESHOLD = 1800
-        hands = self.db.cursor.fetchall()
-
-        # Take that list and create an array of the time between hands
-        times = map(lambda x:long(x[0]), hands)
-        handids = map(lambda x:int(x[1]), hands)
-        winnings = map(lambda x:int(x[4]), hands)
-        print "DEBUG: len(times) %s" %(len(times))
-        diffs = diff(times) # This array is the difference in starttime between consecutive hands
-        index = nonzero(diff(times) > THRESHOLD) # This array represents the indexes into 'times' for start/end times of sessions
-                                                 # ie. times[index[0][0]] is the end of the first session
-        #print "DEBUG: len(index[0]) %s" %(len(index[0]))
-        #print "DEBUG: index %s" %(index)
-        #print "DEBUG: index[0][0] %s" %(index[0][0])
-
-        total = 0
-        last_idx = 0
-        lowidx = 0
-        uppidx = 0
-        results = []
-        # Take all results and format them into a list for feeding into gui model.
-        for i in range(len(index[0])):
-            sid = i                                                             # Session id
-            hds = index[0][i] - last_idx                                        # Number of hands in session
-            stime = strftime("%d/%m/%Y %H:%M", localtime(times[last_idx]))      # Formatted start time
-            etime = strftime("%d/%m/%Y %H:%M", localtime(times[index[0][i]]))   # Formatted end time
-            hph = (times[index[0][i]] - times[last_idx])/60                     # Hands per hour
-            won = sum(winnings[last_idx:index[0][i]])
-            print "DEBUG: range: %s - %s" %(last_idx, index[0][i])
-            
-            results.append([sid, hds, stime, etime, hph, won])
-            print "Hands in session %4s: %4s  Start: %s End: %s HPH: %s Profit: %s" %(sid, hds, stime, etime, hph, won)
-            total = total + (index[0][i] - last_idx)
-            last_idx = index[0][i] + 1
-
-        for row in results:
-            iter = self.liststore.append(row)
-
         vbox.show_all()
 
 def main(argv=None):

pyfpdb/Stats.py

@@ -657,17 +657,15 @@ def ffreq4(stat_dict, player):
     
 if __name__== "__main__":
     c = Configuration.Config()
-    db_connection = Database.Database(c, 'fpdb', 'holdem')
+    db_connection = Database.Database(c)
     h = db_connection.get_last_hand()
-    stat_dict = db_connection.get_stats_from_hand(h)
+    stat_dict = db_connection.get_stats_from_hand(h, "ring")
     
     for player in stat_dict.keys():
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'vpip') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'vpip_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'pfr') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'pfr_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'wtsd') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'profit100_0') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'profit100') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'saw_f') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'n') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'fold_f') 
@@ -675,14 +673,13 @@ if __name__== "__main__":
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'steal') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'f_SB_steal') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'f_BB_steal') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'three_B_0') 
+        print "player = ", player, do_stat(stat_dict, player = player, stat = 'three_B')
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'WMsF') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq1') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq2') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq3') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq4') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_123') 
-        print "player = ", player, do_stat(stat_dict, player = player, stat = 'a_freq_123_0') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb1') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb2') 
         print "player = ", player, do_stat(stat_dict, player = player, stat = 'cb3') 
@@ -694,13 +691,15 @@ if __name__== "__main__":
         print "\n" 
 
     print "\n\nLegal stats:"
+    print "(add _0 to name to display with 0 decimal places, _1 to display with 1, etc)\n"
     for attr in dir():
         if attr.startswith('__'): continue
         if attr in ("Configuration", "Database", "GInitiallyUnowned", "gtk", "pygtk",
                     "player", "c", "db_connection", "do_stat", "do_tip", "stat_dict",
-                    "h"): continue
+                    "h", "re", "re_Percent", "re_Places"): continue
         print "%-14s %s" % (attr, eval("%s.__doc__" % (attr)))
 #        print "            <pu_stat pu_stat_name = \"%s\"> </pu_stat>" % (attr)
+    print
 
     db_connection.close_connection
 

pyfpdb/fpdb.py

@@ -78,7 +78,7 @@ import FpdbSQLQueries
 import Configuration
 from Exceptions import *
 
-VERSION = "0.11"
+VERSION = "0.12"
 
 class fpdb:
     def tab_clicked(self, widget, tab_name):