Support tournament detection = major refactor of Tables.py

pyfpdb/Configuration.py

@@ -377,7 +377,6 @@ class Config:
 
     def edit_layout(self, site_name, max, width = None, height = None,
                     fav_seat = None, locations = None):
-        print "max = ", max
         site_node   = self.get_site_node(site_name)
         layout_node = self.get_layout_node(site_node, max)
         if layout_node == None: return
@@ -480,6 +479,10 @@ class Config:
                           (  0, 280), (121, 280), ( 46,  30) )
         return locations
 
+    def get_supported_sites(self):
+        """Returns the list of supported sites."""
+        return self.supported_sites.keys()
+
     def get_site_parameters(self, site):
         """Returns a dict of the site parameters for the specified site"""
         if not self.supported_sites.has_key(site):
@@ -494,6 +497,7 @@ class Config:
         parms["site_path"]    = self.supported_sites[site].site_path
         parms["table_finder"] = self.supported_sites[site].table_finder
         parms["HH_path"]      = self.supported_sites[site].HH_path
+        parms["site_name"]    = self.supported_sites[site].site_name
         return parms
 
     def set_site_parameters(self, site_name, converter = None, decoder = None,

pyfpdb/Tables.py

@@ -7,7 +7,6 @@ of Table_Window objects representing the windows found.
 """
 #    Copyright 2008, Ray E. Barker
 
-#    
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
 #    the Free Software Foundation; either version 2 of the License, or
@@ -40,7 +39,35 @@ if os.name == 'nt':
 #    FreePokerTools modules
 import Configuration
 
+#    Each TableWindow object must have the following attributes correctly populated:
+#    tw.name = the table name from the title bar, which must to match the table name
+#              from the corresponding hand history.
+#    tw.site = the site name, e.g. PokerStars, FullTilt.  This must match the site
+#            name specified in the config file.
+#    tw.number = This is the system id number for the client table window in the 
+#                format that the system presents it.  This is Xid in Xwindows and
+#                hwnd in Microsoft Windows.
+#    tw.title = The full title from the window title bar.
+#    tw.width, tw.height = The width and height of the window in pixels.  This is 
+#            the internal width and height, not including the title bar and 
+#            window borders.
+#    tw.x, tw.y = The x, y (horizontal, vertical) location of the window relative 
+#            to the top left of the display screen.  This also does not include the
+#            title bar and window borders.  To put it another way, this is the 
+#            screen location of (0, 0) in the working window.
+
 class Table_Window:
+    def __init__(self, info = {}):
+        if info.has_key('number'): self.number = info['number']
+        if info.has_key('exe'):    self.exe    = info['exe']
+        if info.has_key('width'):  self.width  = info['width']
+        if info.has_key('height'): self.height = info['height']
+        if info.has_key('x'):      self.x      = info['x']
+        if info.has_key('y'):      self.y      = info['y']
+        if info.has_key('site'):   self.site   = info['site']
+        if info.has_key('title'):  self.title  = info['title']
+        if info.has_key('name'):   self.name   = info['name']
+
     def __str__(self):
 #    __str__ method for testing
         temp = 'TableWindow object\n'
@@ -51,13 +78,10 @@ class Table_Window:
             temp = temp + "    tournament = %d\n    table = %d" % (self.tournament, self.table)
         return temp
 
-    def get_details(table):
+############################################################################
-        table.game = 'razz'
+#    Top-level discovery routines--these are the modules interface
-        table.max = 8
-        table.struture = 'limit'
-        table.tournament = 0
-
 def discover(c):
+    """Dispatch routine for finding all potential poker client windows."""
     if os.name == 'posix':
         tables = discover_posix(c)
     elif os.name == 'nt':
@@ -66,86 +90,99 @@ def discover(c):
         tables = discover_mac(c)
     else:
         tables = {}
-    
+    return tables
-    return(tables)
 
 def discover_table_by_name(c, tablename):
+    """Dispatch routine for finding poker client windows with the given name."""
     if os.name == 'posix':
-        table = discover_posix_by_name(c, tablename)
+        info = discover_posix_by_name(c, tablename)
     elif os.name == 'nt':
-        table = discover_nt_by_name(c, tablename)
+        info = discover_nt_by_name(c, tablename)
     elif os.name == 'mac':
-        table = discover_mac_by_name(c, tablename)
+        info = discover_mac_by_name(c, tablename)
     else:
-        table = None
+        return None
-    return(table)
+    if info == None:
+        return None
+    return Table_Window(info)
 
+def discover_tournament_table(c, tour_number, tab_number):
+    """Dispatch routine for finding poker clients with tour and table number."""
+    if os.name == 'posix':
+        info = discover_posix_tournament(c, tour_number, tab_number)
+    elif os.name == 'nt':
+        info = discover_nt_tournament(c, tour_number, tab_number)
+    elif os.name == 'mac':
+        info = discover_mac_tournament(c, tour_number, tab_number)
+    else:
+        return None
+    if info:
+        return Table_Window(info)
+    return None
+
+#############################################################################
+# Posix (= XWindows) specific routines
 def discover_posix(c):
-    """    Poker client table window finder for posix/Linux = XWindows."""
+    """Poker client table window finder for posix/Linux = XWindows."""
     tables = {}
     for listing in os.popen('xwininfo -root -tree').readlines():
 #    xwininfo -root -tree -id 0xnnnnn    gets the info on a single window
-        if re.search('Lobby', listing):                            continue
+        for s in c.get_supported_sites():
-        if re.search('Instant Hand History', listing):             continue
+            params = c.get_site_parameters(s)
-        if not re.search('Logged In as ', listing, re.IGNORECASE): continue
+            if re.search(params['table_finder'], listing):
-        if re.search('\"Full Tilt Poker\"', listing):              continue # FTP Lobby
+                if re.search('Lobby', listing):                continue
-        for s in c.supported_sites.keys():
+                if re.search('Instant Hand History', listing): continue
-            if re.search(c.supported_sites[s].table_finder, listing):
+                if re.search('\"Full Tilt Poker\"', listing):  continue # FTP Lobby
-                mo = re.match('\s+([\dxabcdef]+) (.+):.+  (\d+)x(\d+)\+\d+\+\d+  \+(\d+)\+(\d+)', listing)
+                if re.search('History for table:', listing):   continue
-                if mo.group(2) == '(has no name)': continue
+                if re.search('has no name', listing):          continue
-                if re.match('[\(\)\d\s]+', mo.group(2)): continue  # this is a popup
+                info = decode_xwininfo(c, listing)
-                tw = Table_Window()
+                if info['site'] == None:                       continue
-                tw.site = c.supported_sites[s].site_name
+                if info['title'] == info['exe']:               continue
-                tw.number = int(mo.group(1), 0)
+#    this appears to be a poker client, so make a table object for it
-                tw.title  = mo.group(2)
+                tw = Table_Window(info)
-                tw.width  = int( mo.group(3) )
+                eval("%s(tw)" % params['decoder'])
-                tw.height = int( mo.group(4) )
-                tw.x      = int (mo.group(5) )
-                tw.y      = int (mo.group(6) )
-                tw.title  = re.sub('\"', '', tw.title)
-
-#    use this eval thingie to call the title bar decoder specified in the config file
-                eval("%s(tw)" % c.supported_sites[s].decoder)
-                
                 tables[tw.name] = tw
     return tables
 
 def discover_posix_by_name(c, tablename):
-    tables = discover_posix(c)
+    """Find an XWindows poker client of the given name."""
-    for t in tables:
+    for listing in os.popen('xwininfo -root -tree').readlines():
-        if tables[t].name.find(tablename) > -1:
+        if re.search(tablename, listing):
-            return tables[t]
+            if re.search('History for table:', listing): continue
-    return None
+            info = decode_xwininfo(c, listing)
+            if not info['name'] == tablename:            continue
+            return info
+    return False
 
-#
+def discover_posix_tournament(c, t_number, s_number):
-#    The discover_xx functions query the system and report on the poker clients 
+    """Finds the X window for a client, given tournament and table nos."""
-#    currently displayed on the screen.  The discover_posix should give you 
+    search_string = "%s.+Table\s%s" % (t_number, s_number)
-#    some idea how to support other systems.
+    for listing in os.popen('xwininfo -root -tree').readlines():
-#
+        if re.search(search_string, listing):
-#    discover_xx() returns a dict of TableWindow objects--one TableWindow
+            return decode_xwininfo(c, listing)
-#    object for each poker client table on the screen.
+    return False
-#
-#    Each TableWindow object must have the following attributes correctly populated:
-#    tw.site = the site name, e.g. PokerStars, FullTilt.  This must match the site
-#            name specified in the config file.
-#    tw.number = This is the system id number for the client table window in the 
-#            format that the system presents it.
-#    tw.title = The full title from the window title bar.
-#    tw.width, tw.height = The width and height of the window in pixels.  This is 
-#            the internal width and height, not including the title bar and 
-#            window borders.
-#    tw.x, tw.y = The x, y (horizontal, vertical) location of the window relative 
-#            to the top left of the display screen.  This also does not include the
-#            title bar and window borders.  To put it another way, this is the 
-#            screen location of (0, 0) in the working window.
 
-def win_enum_handler(hwnd, titles):
+def decode_xwininfo(c, info_string):
-    titles[hwnd] = win32gui.GetWindowText(hwnd)
+    """Gets window parameters from xwinifo string--XWindows."""
-  
+    info = {}
-
+    mo = re.match('\s+([\dxabcdef]+) (.+):\s\(\"([a-zA-Z.]+)\".+  (\d+)x(\d+)\+\d+\+\d+  \+(\d+)\+(\d+)', info_string)
-def child_enum_handler(hwnd, children):
+    if not mo:
-    print hwnd, win32.GetWindowRect(hwnd)
+        return None
+    else:
+        info['number'] = int( mo.group(1), 0)
+        info['exe']    = mo.group(3)
+        info['width']  = int( mo.group(4) )
+        info['height'] = int( mo.group(5) )
+        info['x']      = int( mo.group(6) )
+        info['y']      = int( mo.group(7) )
+        info['site']   = get_site_from_exe(c, info['exe'])
+        info['title']  = re.sub('\"', '', mo.group(2))
+        title_bits     = re.split(' - ', info['title'])
+        info['name']   = clean_title(title_bits[0])
+    return info
 
+##############################################################################
+#    NT (= Windows) specific routines
 def discover_nt(c):
     """    Poker client table window finder for Windows."""
 #
@@ -185,72 +222,85 @@ def discover_nt(c):
     return tables
 
 def discover_nt_by_name(c, tablename):
-    # this is pretty much identical to the 'search all windows for all poker sites' code, but made to dig just for a specific table name
+    """Finds poker client window with the given table name."""
-    # it could be implemented a bunch better - and we need to not assume the width/height thing that (steffen?) assumed above, we should
+    win32gui.EnumWindows(win_enum_handler, titles)
-    # be able to dig up the window's titlebar handle and get it's information, and such .. but.. for now, i guess this will work.
+    for hwnd in titles.keys():
-    # - eric
+        if titles[hwnd].find(tablename) == -1: continue
+        if titles[hwnd].find("History for table:") > -1: continue
+        if titles[hwnd].find("HUD:") > -1: continue
+        return decode_windows(c, titles[hwnd], hwnd)
+    return False
+
+def discover_nt_tournament(c, tour_number, tab_number):
+    """Finds the Windows window handle for the given tournament/table."""
+    search_string = "%s.+%s" % (t_number, s_number)
+
+    titles ={}
+    win32gui.EnumWindows(win_enum_handler, titles)
+    for hwnd in titles.keys():
+        if re.search(search_string, titles[hwnd]):
+            return decode_windows(c, titles[hwnd], hwnd)
+    return False
+
+def get_nt_exe(hwnd):
+    """Finds the name of the executable that the given window handle belongs to."""
+    processid = win32process.GetWindowThreadProcessId(hwnd)
+    pshandle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, processid[1])
+    return win32process.GetModuleFileNameEx(pshandle, 0)
+
+def decode_windows(c, title, hwnd):
+    """Gets window parameters from the window title and handle--Windows."""
+
+#    I cannot figure out how to get the inside dimensions of the poker table
+#    windows.  So I just assume all borders are 3 thick and all title bars
+#    are 29 high.  No doubt this will be off when used with certain themes.
     b_width = 3
     tb_height = 29
-    titles = {}
-#    tables = discover_nt(c)
-    win32gui.EnumWindows(win_enum_handler, titles)
-    for s in c.supported_sites.keys():
-        for hwnd in titles.keys():
-            processid = win32process.GetWindowThreadProcessId(hwnd)
-            pshandle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, processid[1])
-            exe = win32process.GetModuleFileNameEx(pshandle, 0)
-            if exe.find(c.supported_sites[s].table_finder) == -1:
-                continue
-            if titles[hwnd].find(tablename) > -1:
-                if titles[hwnd].find("History for table:") > -1 or titles[hwnd].find("FPDBHUD") > -1:
-                    continue
-                tw = Table_Window()
-                tw.number = hwnd
-                (x, y, width, height) = win32gui.GetWindowRect(hwnd)
-                tw.title = titles[hwnd]
-                tw.width = int(width) - 2 * b_width
-                tw.height = int(height) - b_width - tb_height
-                tw.x = int(x) + b_width
-                tw.y = int(y) + tb_height
-                tw.site = c.supported_sites[s].site_name
-                if not tw.site == "Unknown" and not c.supported_sites[tw.site].decoder == "Unknown":
-                    eval("%s(tw)" % c.supported_sites[tw.site].decoder)
-                else:
-                    tw.name = tablename
-                return tw
 
-    # if we don't find anything by process name, let's search one more time, and call it Unknown ?
+    info = {}
-    for hwnd in titles.keys():
+    info['number'] = hwnd
-        if titles[hwnd].find(tablename) > -1:
+    info['title'] = re.sub('\"', '', title)
-            if titles[hwnd].find("History for table:") > -1 or titles[hwnd].find("FPDBHUD") > -1:
+    (x, y, w, h) = win32gui.GetWindowRect(hwnd)
-                continue
-            tw = Table_Window()
-            tw.number = hwnd
-            (x, y, width, height) = win32gui.GetWindowRect(hwnd)
-            tw.title = titles[hwnd]
-            tw.width = int(width) - 2 * b_width
-            tw.height = int(height) - b_width - tb_height
-            tw.x = int(x) + b_width
-            tw.y = int(y) + tb_height
-            tw.site = "Unknown"
-            tw.name = tablename
-            return tw
 
+    info['x']      = int(x)  + b_width
+    info['y']      = int( y ) + tb_height
+    info['width']  = int( width ) - 2*b_width
+    info['height'] = int( height ) - b_width - tb_height
+
+    title_bits = re.split(' - ', info['title'])
+    info['name'] = title_bits[0]
+    info['site']   = get_site_from_exe(c, info['exe'])
+
+    return info
+
+def win_enum_handler(hwnd, titles):
+    titles[hwnd] = win32gui.GetWindowText(hwnd)
+  
+###################################################################
+#    Utility routines used by all the discoverers.
+def get_site_from_exe(c, exe):
+    """Look up the site from config, given the exe."""
+    for s in c.get_supported_sites():
+        params = c.get_site_parameters(s)
+        if re.search(params['table_finder'], exe):
+            return params['site_name']
     return None
 
-def discover_mac(c):
+def clean_title(name):
-    """    Poker client table window finder for Macintosh."""
+    """Clean the little info strings from the table name."""
-    tables = {}
+#    these strings could go in a config file
-    return tables
+    for pattern in [' \(6 max\)', ' \(heads up\)', ' \(deep\)',
-
+                ' \(deep hu\)', ' \(deep 6\)', ' \(2\)',
-def discover_mac_by_name(c, tablename):
+                ' \(edu\)', ' \(edu, 6 max\)', ' \(6\)',
-    # again, i have no mac to test this on, sorry -eric
+                ' no all-in', ' fast', ',', ' 50BB min', '\s+$']:
-    return discover_mac(c)
+        name = re.sub(pattern, '', name)
-
+    name = name.rstrip()
+    return name
 
 def pokerstars_decode_table(tw):
-#    extract the table name OR the tournament number and table name from the title
+#    Extract poker information from the window title.  This is not needed for
-#    other info in title is redundant with data in the database 
+#    fpdb, since all that information is available in the db via new_hand_number.
+#    This is needed only when using the HUD with a backend less integrated.
     title_bits = re.split(' - ', tw.title)
     name = title_bits[0]
     mo = re.search('Tournament (\d+) Table (\d+)', name)
@@ -260,12 +310,8 @@ def pokerstars_decode_table(tw):
         tw.name       = name
     else:
         tw.tournament = None
-        for pattern in [' no all-in', ' fast', ',', ' 50BB min']:
+        tw.name = clean_title(name)
-            name = re.sub(pattern, '', name)
+    mo = re.search('(Razz|Stud H/L|Stud|Omaha H/L|Omaha|Hold\'em|5-Card Draw|Triple Draw 2-7 Lowball|Badugi)', tw.title)
-        name = re.sub('\s+$', '', name)
-        tw.name = name
-
-    mo = re.search('(Razz|Stud H/L|Stud|Omaha H/L|Omaha|Hold\'em|5-Card Draw|Triple Draw 2-7 Lowball)', tw.title)
     
     tw.game = mo.group(1).lower()
     tw.game = re.sub('\'', '', tw.game)
@@ -288,25 +334,103 @@ def pokerstars_decode_table(tw):
         pass
 
 def fulltilt_decode_table(tw):
-#    extract the table name OR the tournament number and table name from the title
+#    Extract poker information from the window title.  This is not needed for
-#    other info in title is redundant with data in the database 
+#    fpdb, since all that information is available in the db via new_hand_number.
+#    This is needed only when using the HUD with a backend less integrated.
     title_bits = re.split(' - ', tw.title)
     name = title_bits[0]
     tw.tournament = None
-    for pattern in [' (6 max)', ' (heads up)', ' (deep)',
+    tw.name = clean_title(name)
-                    ' (deep hu)', ' (deep 6)', ' (2)',
+
-                    ' (edu)', ' (edu, 6 max)', ' (6)' ]:
+def clean_title(name):
+    """Clean the little info strings from the table name."""
+#    these strings could go in a config file
+    for pattern in [' \(6 max\)', ' \(heads up\)', ' \(deep\)',
+                ' \(deep hu\)', ' \(deep 6\)', ' \(2\)',
+                ' \(edu\)', ' \(edu, 6 max\)', ' \(6\)',
+                ' no all-in', ' fast', ',', ' 50BB min', '\s+$']:
         name = re.sub(pattern, '', name)
-#    (tw.name, trash) = name.split(r' (', 1)
+    name = name.rstrip()
-    tw.name = name.rstrip()
+    return name
+
+###########################################################################
+#    Mac specific routines....all stubs for now
+def discover_mac_tournament(c, tour_number, tab_number):
+    """Mac users need help."""
+    return None
+
+def discover_mac(c):
+    """Poker client table window finder for Macintosh."""
+    tables = {}
+    return tables
+
+def discover_mac_by_name(c, tablename):
+    """Oh, the humanity."""
+    # again, i have no mac to test this on, sorry -eric
+    return None
+
+#def discover_nt_by_name(c, tablename):
+#    # this is pretty much identical to the 'search all windows for all poker sites' code, but made to dig just for a specific table name
+#    # it could be implemented a bunch better - and we need to not assume the width/height thing that (steffen?) assumed above, we should
+#    # be able to dig up the window's titlebar handle and get it's information, and such .. but.. for now, i guess this will work.
+#    # - eric
+#    b_width = 3
+#    tb_height = 29
+#    titles = {}
+##    tables = discover_nt(c)
+#    win32gui.EnumWindows(win_enum_handler, titles)
+#    for s in c.supported_sites.keys():
+#        for hwnd in titles.keys():
+#            processid = win32process.GetWindowThreadProcessId(hwnd)
+#            pshandle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, processid[1])
+#            exe = win32process.GetModuleFileNameEx(pshandle, 0)
+#            if exe.find(c.supported_sites[s].table_finder) == -1:
+#                continue
+#            if titles[hwnd].find(tablename) > -1:
+#                if titles[hwnd].find("History for table:") > -1 or titles[hwnd].find("FPDBHUD") > -1:
+#                    continue
+#                tw = Table_Window()
+#                tw.number = hwnd
+#                (x, y, width, height) = win32gui.GetWindowRect(hwnd)
+#                tw.title = titles[hwnd]
+#                tw.width = int(width) - 2 * b_width
+#                tw.height = int(height) - b_width - tb_height
+#                tw.x = int(x) + b_width
+#                tw.y = int(y) + tb_height
+#                tw.site = c.supported_sites[s].site_name
+#                if not tw.site == "Unknown" and not c.supported_sites[tw.site].decoder == "Unknown":
+#                    eval("%s(tw)" % c.supported_sites[tw.site].decoder)
+#                else:
+#                    tw.name = tablename
+#                return tw
+#    
+#    # if we don't find anything by process name, let's search one more time, and call it Unknown ?
+#    for hwnd in titles.keys():
+#        if titles[hwnd].find(tablename) > -1:
+#            if titles[hwnd].find("History for table:") > -1 or titles[hwnd].find("FPDBHUD") > -1:
+#                continue
+#            tw = Table_Window()
+#            tw.number = hwnd
+#            (x, y, width, height) = win32gui.GetWindowRect(hwnd)
+#            tw.title = titles[hwnd]
+#            tw.width = int(width) - 2 * b_width
+#            tw.height = int(height) - b_width - tb_height
+#            tw.x = int(x) + b_width
+#            tw.y = int(y) + tb_height
+#            tw.site = "Unknown"
+#            tw.name = tablename
+#            return tw
+#    
+#    return None
 
 if __name__=="__main__":
     c = Configuration.Config()
-    print discover_table_by_name(c, "Catacaos")
-    tables = discover(c)
 
+    print discover_table_by_name(c, "Ostara V")
+    print discover_tournament_table(c, "119736621", "1")
+
+    tables = discover(c)
     for t in tables.keys():
-        print "t = ", t
         print tables[t]
 
     print "press enter to continue"