You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
417 lines
19 KiB
417 lines
19 KiB
#!/usr/bin/env python |
|
# -*- coding: utf-8 -*- |
|
|
|
#Copyright 2008-2011 Steffen Schaumburg |
|
#This program is free software: you can redistribute it and/or modify |
|
#it under the terms of the GNU Affero General Public License as published by |
|
#the Free Software Foundation, version 3 of the License. |
|
# |
|
#This program is distributed in the hope that it will be useful, |
|
#but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
#GNU General Public License for more details. |
|
# |
|
#You should have received a copy of the GNU Affero General Public License |
|
#along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
#In the "official" distribution you can find the license in agpl-3.0.txt. |
|
|
|
import L10n |
|
_ = L10n.get_translation() |
|
|
|
import threading |
|
import pygtk |
|
pygtk.require('2.0') |
|
import gtk |
|
import os |
|
from time import time, strftime |
|
|
|
import fpdb_import |
|
import Database |
|
import Filters |
|
|
|
class GuiPositionalStats (threading.Thread): |
|
def __init__(self, config, querylist, debug=True): |
|
self.debug = debug |
|
self.conf = config |
|
self.sql = querylist |
|
self.MYSQL_INNODB = 2 |
|
self.PGSQL = 3 |
|
self.SQLITE = 4 |
|
|
|
# create new db connection to avoid conflicts with other threads |
|
self.db = Database.Database(self.conf, sql=self.sql) |
|
self.cursor = self.db.cursor |
|
|
|
settings = {} |
|
settings.update(self.conf.get_db_parameters()) |
|
settings.update(self.conf.get_import_parameters()) |
|
settings.update(self.conf.get_default_paths()) |
|
|
|
filters_display = { "Heroes" : True, |
|
"Sites" : True, |
|
"Games" : False, |
|
"Limits" : True, |
|
"LimitSep" : True, |
|
"Seats" : True, |
|
"SeatSep" : True, |
|
"Dates" : True, |
|
"Button1" : True, |
|
"Button2" : False |
|
} |
|
|
|
self.filters = Filters.Filters(self.db, self.conf, self.sql, display = filters_display) |
|
self.filters.registerButton1Name(_("Refresh")) |
|
self.filters.registerButton1Callback(self.refreshStats) |
|
|
|
# ToDo: store in config |
|
# ToDo: create popup to adjust column config |
|
# columns to display, keys match column name returned by sql, values in tuple are: |
|
# is column displayed, column heading, xalignment, formatting |
|
self.columns = [ ["game", True, "Game", 0.0, "%s"] |
|
, ["hand", False, "Hand", 0.0, "%s"] # true not allowed for this line |
|
, ["plposition", False, "Posn", 1.0, "%s"] # true not allowed for this line (set in code) |
|
, ["n", True, "Hds", 1.0, "%d"] |
|
, ["avgseats", True, "Seats", 1.0, "%3.1f"] |
|
, ["vpip", True, "VPIP", 1.0, "%3.1f"] |
|
, ["pfr", True, "PFR", 1.0, "%3.1f"] |
|
, ["pf3", True, "PF3", 1.0, "%3.1f"] |
|
, ["steals", True, "Steals", 1.0, "%3.1f"] |
|
, ["saw_f", True, "Saw_F", 1.0, "%3.1f"] |
|
, ["sawsd", True, "SawSD", 1.0, "%3.1f"] |
|
, ["wtsdwsf", True, "WtSDwsF", 1.0, "%3.1f"] |
|
, ["wmsd", True, "W$SD", 1.0, "%3.1f"] |
|
, ["flafq", True, "FlAFq", 1.0, "%3.1f"] |
|
, ["tuafq", True, "TuAFq", 1.0, "%3.1f"] |
|
, ["rvafq", True, "RvAFq", 1.0, "%3.1f"] |
|
, ["pofafq", False, "PoFAFq", 1.0, "%3.1f"] |
|
, ["net", True, "Net($)", 1.0, "%6.2f"] |
|
, ["bbper100", True, "bb/100", 1.0, "%4.2f"] |
|
, ["rake", True, "Rake($)", 1.0, "%6.2f"] |
|
, ["bb100xr", True, "bbxr/100", 1.0, "%4.2f"] |
|
, ["variance", True, "Variance", 1.0, "%5.2f"] |
|
] |
|
|
|
self.stat_table = None |
|
self.stats_frame = None |
|
self.stats_vbox = None |
|
|
|
self.main_hbox = gtk.HBox(False, 0) |
|
self.main_hbox.show() |
|
|
|
self.stats_frame = gtk.Frame() |
|
self.stats_frame.set_label_align(0.0, 0.0) |
|
self.stats_frame.show() |
|
self.stats_vbox = gtk.VBox(False, 0) |
|
self.stats_vbox.show() |
|
|
|
# This could be stored in config eventually, or maybe configured in this window somehow. |
|
# Each posncols element is the name of a column returned by the sql |
|
# query (in lower case) and each posnheads element is the text to use as |
|
# the heading in the GUI. Both sequences should be the same length. |
|
# To miss columns out remove them from both tuples (the 1st 2 elements should always be included). |
|
# To change the heading just edit the second list element as required |
|
# If the first list element does not match a query column that pair is ignored |
|
self.posncols = ( "game", "avgseats", "plposition", "vpip", "pfr", "pf3", "steals" |
|
, "saw_f", "sawsd", "wtsdwsf", "wmsd", "flafq", "tuafq", "rvafq" |
|
, "pofafq", "net", "bbper100", "profitperhand", "variance", "n" |
|
) |
|
self.posnheads = ( "Game", "Seats", "Posn", "VPIP", "PFR", "PF3", "Steals" |
|
, "Saw_F", "SawSD", "WtSDwsF", "W$SD", "FlAFq", "TuAFq", "RvAFq" |
|
, "PoFAFq", "Net($)", "bb/100", "$/hand", "Variance", "Hds" |
|
) |
|
|
|
self.fillStatsFrame(self.stats_vbox) |
|
self.stats_frame.add(self.stats_vbox) |
|
|
|
self.main_hbox.pack_start(self.filters.get_vbox()) |
|
self.main_hbox.pack_start(self.stats_frame) |
|
|
|
|
|
def get_vbox(self): |
|
"""returns the vbox of this thread""" |
|
return self.main_hbox |
|
|
|
def toggleCallback(self, widget, data=None): |
|
# print "%s was toggled %s" % (data, ("OFF", "ON")[widget.get_active()]) |
|
self.activesite = data |
|
print (_("DEBUG: ") + _("activesite set to %s") % (self.activesite)) |
|
|
|
def refreshStats(self, widget, data): |
|
try: self.stats_vbox.destroy() |
|
except AttributeError: pass |
|
self.stats_vbox = gtk.VBox(False, 0) |
|
self.stats_vbox.show() |
|
self.stats_frame.add(self.stats_vbox) |
|
self.fillStatsFrame(self.stats_vbox) |
|
|
|
def fillStatsFrame(self, vbox): |
|
sites = self.filters.getSites() |
|
heroes = self.filters.getHeroes() |
|
siteids = self.filters.getSiteIds() |
|
limits = self.filters.getLimits() |
|
seats = self.filters.getSeats() |
|
dates = self.filters.getDates() |
|
sitenos = [] |
|
playerids = [] |
|
|
|
# Which sites are selected? |
|
for site in sites: |
|
if sites[site] == True: |
|
sitenos.append(siteids[site]) |
|
self.cursor.execute(self.sql.query['getPlayerId'], (heroes[site],)) |
|
result = self.db.cursor.fetchall() |
|
if len(result) == 1: |
|
playerids.append(result[0][0]) |
|
|
|
if not sitenos: |
|
#Should probably pop up here. |
|
print _("No sites selected - defaulting to PokerStars") |
|
sitenos = [2] |
|
if not playerids: |
|
print _("No player ids found") |
|
return |
|
if not limits: |
|
print _("No limits found") |
|
return |
|
|
|
self.createStatsTable(vbox, playerids, sitenos, limits, seats, dates) |
|
|
|
def createStatsTable(self, vbox, playerids, sitenos, limits, seats, dates): |
|
|
|
starttime = time() |
|
colalias,colshow,colheading,colxalign,colformat = 0,1,2,3,4 |
|
row = 0 |
|
col = 0 |
|
|
|
tmp = self.sql.query['playerStatsByPosition'] |
|
tmp = self.refineQuery(tmp, playerids, sitenos, limits, seats, dates) |
|
self.cursor.execute(tmp) |
|
result = self.cursor.fetchall() |
|
colnames = [desc[0].lower() for desc in self.cursor.description] |
|
|
|
liststore = gtk.ListStore(*([str] * len(colnames))) |
|
view = gtk.TreeView(model=liststore) |
|
view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) |
|
vbox.pack_start(view, expand=False, padding=3) |
|
# left-aligned cells: |
|
textcell = gtk.CellRendererText() |
|
# centred cells: |
|
textcell50 = gtk.CellRendererText() |
|
textcell50.set_property('xalign', 0.5) |
|
# right-aligned cells: |
|
numcell = gtk.CellRendererText() |
|
numcell.set_property('xalign', 1.0) |
|
listcols = [] |
|
|
|
for t in self.posnheads: |
|
listcols.append(gtk.TreeViewColumn(self.posnheads[col])) |
|
view.append_column(listcols[col]) |
|
if col == 0: |
|
listcols[col].pack_start(textcell, expand=True) |
|
listcols[col].add_attribute(textcell, 'text', col) |
|
listcols[col].set_expand(True) |
|
elif col in (1, 2): |
|
listcols[col].pack_start(textcell50, expand=True) |
|
listcols[col].add_attribute(textcell50, 'text', col) |
|
listcols[col].set_expand(True) |
|
else: |
|
listcols[col].pack_start(numcell, expand=True) |
|
listcols[col].add_attribute(numcell, 'text', col) |
|
listcols[col].set_expand(True) |
|
col +=1 |
|
|
|
# Code below to be used when full column data structures implemented like in player stats: |
|
|
|
# Create header row eg column: ("game", True, "Game", 0.0, "%s") |
|
#for col, column in enumerate(cols_to_show): |
|
# if column[colalias] == 'game' and holecards: |
|
# s = [x for x in self.columns if x[colalias] == 'hand'][0][colheading] |
|
# else: |
|
# s = column[colheading] |
|
# listcols.append(gtk.TreeViewColumn(s)) |
|
# view.append_column(listcols[col]) |
|
# if column[colformat] == '%s': |
|
# if column[colxalign] == 0.0: |
|
# listcols[col].pack_start(textcell, expand=True) |
|
# listcols[col].add_attribute(textcell, 'text', col) |
|
# else: |
|
# listcols[col].pack_start(textcell50, expand=True) |
|
# listcols[col].add_attribute(textcell50, 'text', col) |
|
# listcols[col].set_expand(True) |
|
# else: |
|
# listcols[col].pack_start(numcell, expand=True) |
|
# listcols[col].add_attribute(numcell, 'text', col) |
|
# listcols[col].set_expand(True) |
|
# #listcols[col].set_alignment(column[colxalign]) # no effect? |
|
|
|
rows = len(result) |
|
|
|
last_game,last_seats,sqlrow = "","",0 |
|
while sqlrow < rows: |
|
rowprinted=0 |
|
treerow = [] |
|
avgcol = colnames.index('avgseats') |
|
for col,colname in enumerate(self.posncols): |
|
if colname in colnames: |
|
sqlcol = colnames.index(colname) |
|
else: |
|
continue |
|
if result[sqlrow][sqlcol]: |
|
if sqlrow == 0: |
|
value = result[sqlrow][sqlcol] |
|
rowprinted=1 |
|
elif result[sqlrow][0] != last_game: |
|
value = ' ' |
|
elif 'show' in seats and seats['show'] and result[sqlrow][avgcol] != last_seats: |
|
value = ' ' |
|
else: |
|
value = result[sqlrow][sqlcol] |
|
rowprinted=1 |
|
else: |
|
l = gtk.Label(' ') |
|
value = ' ' |
|
if value and value != -999: |
|
treerow.append(value) |
|
else: |
|
treerow.append(' ') |
|
iter = liststore.append(treerow) |
|
last_game = result[sqlrow][0] |
|
last_seats = result[sqlrow][avgcol] |
|
if rowprinted: |
|
sqlrow = sqlrow+1 |
|
row = row + 1 |
|
|
|
# show totals at bottom |
|
tmp = self.sql.query['playerStats'] |
|
tmp = self.refineQuery(tmp, playerids, sitenos, limits, seats, dates) |
|
self.cursor.execute(tmp) |
|
result = self.cursor.fetchall() |
|
rows = len(result) |
|
colnames = [desc[0].lower() for desc in self.cursor.description] |
|
|
|
# blank row between main stats and totals: |
|
col = 0 |
|
treerow = [' ' for x in self.posncols] |
|
iter = liststore.append(treerow) |
|
row = row + 1 |
|
|
|
for sqlrow in range(rows): |
|
treerow = [] |
|
for col,colname in enumerate(self.posncols): |
|
if colname in colnames: |
|
sqlcol = colnames.index(colname) |
|
elif colname != "plposition": |
|
continue |
|
if colname == 'plposition': |
|
l = gtk.Label('Totals') |
|
value = 'Totals' |
|
elif result[sqlrow][sqlcol]: |
|
l = gtk.Label(result[sqlrow][sqlcol]) |
|
value = result[sqlrow][sqlcol] |
|
else: |
|
l = gtk.Label(' ') |
|
value = ' ' |
|
if value and value != -999: |
|
treerow.append(value) |
|
else: |
|
treerow.append(' ') |
|
iter = liststore.append(treerow) |
|
row = row + 1 |
|
vbox.show_all() |
|
|
|
self.db.rollback() |
|
print _("Positional Stats page displayed in %4.2f seconds") % (time() - starttime) |
|
#end def fillStatsFrame(self, vbox): |
|
|
|
def refineQuery(self, query, playerids, sitenos, limits, seats, dates): |
|
if playerids: |
|
nametest = str(tuple(playerids)) |
|
nametest = nametest.replace("L", "") |
|
nametest = nametest.replace(",)",")") |
|
query = query.replace("<player_test>", nametest) |
|
else: |
|
query = query.replace("<player_test>", "1 = 2") |
|
|
|
if seats: |
|
query = query.replace('<seats_test>', 'between ' + str(seats['from']) + ' and ' + str(seats['to'])) |
|
if 'show' in seats and seats['show']: |
|
query = query.replace('<groupbyseats>', ',hc.activeSeats') |
|
query = query.replace('<orderbyseats>', ',stats.AvgSeats') |
|
else: |
|
query = query.replace('<groupbyseats>', '') |
|
query = query.replace('<orderbyseats>', '') |
|
else: |
|
query = query.replace('<seats_test>', 'between 0 and 100') |
|
query = query.replace('<groupbyseats>', '') |
|
query = query.replace('<orderbyseats>', '') |
|
|
|
if [x for x in limits if str(x).isdigit()]: |
|
blindtest = str(tuple([x for x in limits if str(x).isdigit()])) |
|
blindtest = blindtest.replace("L", "") |
|
blindtest = blindtest.replace(",)",")") |
|
query = query.replace("<gtbigBlind_test>", "gt.bigBlind in " + blindtest) |
|
else: |
|
query = query.replace("<gtbigBlind_test>", "gt.bigBlind = -1 ") |
|
|
|
groupLevels = "show" not in str(limits) |
|
if groupLevels: |
|
if self.db.backend == self.MYSQL_INNODB: |
|
bigblindselect = """concat('$' |
|
,trim(leading ' ' from |
|
case when min(gt.bigBlind) < 100 |
|
then format(min(gt.bigBlind)/100.0, 2) |
|
else format(min(gt.bigBlind)/100.0, 0) |
|
end) |
|
,' - $' |
|
,trim(leading ' ' from |
|
case when max(gt.bigBlind) < 100 |
|
then format(max(gt.bigBlind)/100.0, 2) |
|
else format(max(gt.bigBlind)/100.0, 0) |
|
end) |
|
) """ |
|
else: |
|
bigblindselect = """'$' || |
|
trim(leading ' ' from |
|
case when min(gt.bigBlind) < 100 |
|
then to_char(min(gt.bigBlind)/100.0,'90D00') |
|
else to_char(min(gt.bigBlind)/100.0,'999990') |
|
end) |
|
|| ' - $' || |
|
trim(leading ' ' from |
|
case when max(gt.bigBlind) < 100 |
|
then to_char(max(gt.bigBlind)/100.0,'90D00') |
|
else to_char(max(gt.bigBlind)/100.0,'999990') |
|
end) """ |
|
bigblindselect = "cast('' as char)" # avoid odd effects when some posns and/or seats |
|
# are missing from some limits (dunno why cast is |
|
# needed but it says "unknown type" otherwise?! |
|
query = query.replace("<selectgt.bigBlind>", bigblindselect) |
|
query = query.replace("<groupbygt.bigBlind>", "") |
|
query = query.replace("<hcgametypeId>", "-1") |
|
query = query.replace("<hgametypeId>", "-1") |
|
else: |
|
if self.db.backend == self.MYSQL_INNODB: |
|
bigblindselect = """concat('$', trim(leading ' ' from |
|
case when gt.bigBlind < 100 |
|
then format(gt.bigBlind/100.0, 2) |
|
else format(gt.bigBlind/100.0, 0) |
|
end |
|
) )""" |
|
else: |
|
bigblindselect = """'$' || trim(leading ' ' from |
|
case when gt.bigBlind < 100 |
|
then to_char(gt.bigBlind/100.0,'90D00') |
|
else to_char(gt.bigBlind/100.0,'999990') |
|
end |
|
) """ |
|
query = query.replace("<selectgt.bigBlind>", bigblindselect) |
|
query = query.replace("<groupbygt.bigBlind>", ",gt.bigBlind") |
|
query = query.replace("<hcgametypeId>", "hc.gametypeId") |
|
query = query.replace("<hgametypeId>", "h.gametypeId") |
|
|
|
# Filter on dates |
|
query = query.replace("<datestest>", " between '" + dates[0] + "' and '" + dates[1] + "'") |
|
|
|
#print "query =\n", query |
|
return(query) |
|
#end def refineQuery(self, query, playerids, sitenos, limits):
|
|
|