update ui

app.py

@@ -5,7 +5,8 @@ import os
 from tempfile import mkdtemp
 from timeit import default_timer as timer
 from hand_record import create_hand_record_pdf
-from pbn_util import validate_pbn, create_single_pbn_string
+from pbn_util import create_pbn_file
+from bridge_util import validate_dataframe, df_info, roll_direction
 
 # Download model and libraries from repo
 try:
@@ -45,7 +46,8 @@ def predict(image_path, top_hand_idx):
         df = default_df.copy(deep=True)#pd.DataFrame(['♠', '♥', '♦', '♣'], columns=[''])
         for hand in hands:
             df[hand.direction] = [''.join(c) for c in hand.cards]
-    except:
+    except Exception as e:
+        print(e)
         raise gr.Error('Cannot process image')
 
     end = timer()
@@ -67,17 +69,15 @@ def save_file(df, cache_dir, files, board_no):
         d = mkdtemp()
 
     try:
-        pbn_str = create_single_pbn_string(df, board_no=board_no)
-        validate_pbn(pbn_str)
+        validate_dataframe(df)
     except Exception as e:
         print(e)
-        gr.Warning(f'Fail to save: {e}')
+        gr.Warning(f'Fail to save pbn. Error in table entries. {e}')
         return files, files, d
 
     file_name = f'board_{board_no:03d}.pbn'
     file_path = os.path.join(d,file_name)
-    with open(file_path, 'w') as f:
-        f.write(pbn_str)
+    create_pbn_file(df, file_path)
 
     if not file_path in files:
         files.append(file_path)
@@ -87,6 +87,13 @@ def create_hand_record(files, event, site):
     file_path = create_hand_record_pdf(files, event=event, site=site)
     return file_path
 
+def print_df_info(df):
+    return df_info(df)
+
+def change_direction_in_df(df, top_direction_idx:int, current_top_idx:int):
+    roll_idx = current_top_idx - top_direction_idx 
+    return roll_direction(df, roll_idx), top_direction_idx
+
 with gr.Blocks(css=custom_css) as demo:
     gr.Markdown(
         """
@@ -111,6 +118,7 @@ with gr.Blocks(css=custom_css) as demo:
     total = gr.State(0)
     gradio_cache_dir = gr.State()
     files = gr.State([])
+    current_top_idx = gr.State(0)
     with gr.Tab('Scan Image'):
         with gr.Row():
             with gr.Column():
@@ -139,6 +147,7 @@ with gr.Blocks(css=custom_css) as demo:
                                 headers=['', 'N', 'E', 'S', 'W'],
                                 interactive=True, column_widths=['8%', '23%','23%','23%','23%'])
                 b2 = gr.Button('Save')
+                b_info_panel = gr.TextArea(lines=5,show_label=False, interactive=False)
                 b3 = gr.File(interactive=False, file_count='multiple')
 
     with gr.Tab('Hand Record'):
@@ -155,5 +164,7 @@ with gr.Blocks(css=custom_css) as demo:
     a2.add([a1,b1])
     a3.click(predict, [a1, a_top], [b1])
     b2.click(save_file, [b1, gradio_cache_dir, files, a_board_no], [b3, tab2_upload_file, gradio_cache_dir])
+    b1.change(print_df_info, b1, b_info_panel)
+    a_top.change(change_direction_in_df, [b1, a_top, current_top_idx], [b1, current_top_idx])
 
 demo.queue().launch()

bridge_util.py

@@ -0,0 +1,104 @@
+from bridgebots import Suit, Direction, Card, Rank
+from bridgebots.pbn import from_pbn_deal
+from pbn_util import pbn_deal_string
+from collections import Counter
+
+DEALER_LIST = ['N', 'E', 'S', 'W']
+VULNERABILITY_LIST = ["None","NS","EW","All","NS","EW","All","None","EW","All","None","NS","All","None","NS","EW"]
+SUITS = [Suit.SPADES, Suit.HEARTS, Suit.DIAMONDS, Suit.CLUBS]
+RANKS = [r.abbreviation() for r in Rank]
+
+def get_vulnerabilty_from_board_number(board_no: int) -> str:
+    # Get vulnerability from board number
+    return VULNERABILITY_LIST[(board_no-1) % 16]
+
+def get_dealer_from_board_number(board_no: int) -> str:
+    return DEALER_LIST[(board_no-1) % 4]
+
+def validate_dataframe(df) -> None:
+    """ validate submitted dataframe before saving pbn """
+    # Check column names to be NESW
+    missing_direction = [direction.abbreviation() for direction in Direction if not direction.abbreviation() in df.columns]
+    assert len(missing_direction) == 0, f"Expect directions in table to be {','.join([d.abbreviation() for d in Direction])}" + \
+      f" missing {','.join(missing_direction)}"
+
+    err_msg = ''
+    # Check each direction to have 13 cards
+    invalid_num_cards_direction = [direction.name for direction in Direction if len((''.join(df[direction.abbreviation()].tolist()))) != 13]
+    if invalid_num_cards_direction:
+        err_msg += f'Expect 13 cards in each hand, received invalid number of cards in {",".join(invalid_num_cards_direction)}. '
+
+    # Check card values in RANKS
+    cards = []
+    invalid_values = set()
+    for direction in Direction:
+        for ranks, suit in zip(df[direction.abbreviation()], SUITS):
+            for r in ranks:
+                try:
+                    Rank.from_str(r)
+                except:
+                    invalid_values.add(r)
+    assert not invalid_values, f'Expect card values in {",".join(RANKS)}, received {invalid_values}'
+
+    for direction in Direction:
+        for ranks, suit in zip(df[direction.abbreviation()], SUITS):
+            cards.extend([Card(rank=Rank.from_str(v), suit=suit) for v in ranks])
+
+    # Check duplicated and missing cards
+    duplicated, missing = get_invalid_cards(cards)
+
+    if len(duplicated) > 0:
+        err_msg += f'Duplicated cards: {duplicated}. '
+    if len(missing) > 0:
+        err_msg += f'Missing cards: {missing}. '
+    assert not err_msg, err_msg
+
+def df_info(df):
+    # missing_direction = [direction.abbreviation() for direction in Direction if not direction.abbreviation() in df.columns]
+    num_cards_direction = {direction.name:  len((''.join(df[direction.abbreviation()].tolist()))) for direction in Direction}
+
+    invalid_values = set()
+    for direction in Direction:
+        for ranks, suit in zip(df[direction.abbreviation()], SUITS):
+            for r in ranks:
+                try:
+                    Rank.from_str(r)
+                except:
+                    invalid_values.add(r)
+
+    if invalid_values:
+        return f'Expect card values in {",".join(RANKS)}, received {invalid_values}'
+
+    cards = []
+    for direction in Direction:
+        for ranks, suit in zip(df[direction.abbreviation()], SUITS):
+            cards.extend([Card(rank=Rank.from_str(v), suit=suit) for v in ranks])
+
+    # Check duplicated and missing cards
+    duplicated, missing = get_invalid_cards(cards)
+
+    if (not duplicated) and (not missing) and not [True for n in num_cards_direction.values() if n!=13]:
+        return f'It looks good!'
+
+    print_info = f'Number of cards: {num_cards_direction} \n'
+    print_info += f'Duplicated cards: {",".join(sorted(map(Card.__repr__,duplicated)))} \n'
+    print_info += f'Missing cards: {",".join(sorted(map(Card.__repr__,missing)))}'
+    return print_info
+
+    
+
+
+def get_invalid_cards(cards: list[Card]) -> tuple[set, set]:
+    """Get duplicated and missing cards"""
+    counter_cards = Counter(cards)
+    duplicated = {c for c, cnt in counter_cards.items() if cnt > 1}
+    missing = {Card(s,r) for r in Rank for s in Suit if not Card(s,r) in counter_cards.keys()}
+
+    return duplicated, missing
+
+def roll_direction(df, idx):
+    new_df = df.copy(deep=True) 
+    for i, direction in enumerate(DEALER_LIST):
+        new_direction = DEALER_LIST[(idx+i)%4]
+        new_df[direction] = df[new_direction]
+    return new_df

dds_util.py

@@ -105,20 +105,4 @@ def get_dd_tricks(deal):
 
 """
 End
-"""
-
-DD_DIRECTIONS = ['N', 'S', 'E', 'W']
-DD_SUITS = ['NT', 'S', 'H', 'D', 'C']
-def get_result_table(pbn_deal_string):
-    try:
-        dd_tricks_string = get_dd_tricks(pbn_deal_string)
-    except Exception as e:
-        print(e)
-        raise ValueError(e)
-    s = '[OptimumResultTable "Declarer;Denomination\\2R;Result\\2R"]\n'
-    for i, char in enumerate(dd_tricks_string):
-        direction = DD_DIRECTIONS[i//5]
-        suit = DD_SUITS[i%5]
-        tricks = int(char, 16)
-        s += f'{direction} {suit} {tricks}\n'
-    return s
+"""

hand_record.py

@@ -2,7 +2,7 @@ from fpdf import FPDF
 import tempfile
 import os
 import bridgebots
-from pbn_util import merge_pbn, parse_pbn, parse_dds_table
+from pbn_util import merge_pbn, parse_pbn
 
 DEALER_LIST = ['N', 'E', 'S', 'W']
 VULNERABILITY_LIST = ["None","NS","EW","All","NS","EW","All","None","EW","All","None","NS","All","None","NS","EW"]
@@ -10,8 +10,6 @@ SUITS = [bridgebots.Suit.SPADES, bridgebots.Suit.HEARTS, bridgebots.Suit.DIAMOND
 SUIT_SYMBOLS = ['♠','♥','♦','♣']
 
 
-suit_symbols = ['♠','♥','♦','♣']
-
 class PDF(FPDF):
     value_column_span = 7
     def __init__(self, event, site, *args, **kwargs):
@@ -89,7 +87,7 @@ class PDF(FPDF):
                 self.set_font_size(16)
                 row.cell(str(board_no), colspan=6, rowspan=2, align='C', v_align='C', padding=(2,0,0,0))
                 self.set_font_size(10)
-                for i, (suit, values) in enumerate(zip(suit_symbols, get_values(deal, 'N'))):
+                for i, (suit, values) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'N'))):
                     if i!=0:
                         row = table.row()
                     if i == 2:
@@ -98,7 +96,7 @@ class PDF(FPDF):
 
                 # row = table.row()
                 # row = table.row()
-                for i, (suit, values1, values2) in enumerate(zip(suit_symbols, get_values(deal, 'W'), get_values(deal, 'E'))):
+                for i, (suit, values1, values2) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'W'), get_values(deal, 'E'))):
                     row = table.row()
                     row.cell('', colspan=1, rowspan=1)
                     print_suit_values(self, row, suit, values1)
@@ -109,7 +107,7 @@ class PDF(FPDF):
                 # row = table.row()
                 row = table.row()
                 row.cell('', colspan=6, rowspan=4)
-                for i, (suit, values) in enumerate(zip(suit_symbols, get_values(deal, 'S'))):
+                for i, (suit, values) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'S'))):
                     if i!=0:
                         row = table.row()
                     print_suit_values(self, row, suit, values)
@@ -131,10 +129,10 @@ class PDF(FPDF):
                 self.set_font_size(5)
                 row.cell('NT', align='C')
                 self.set_font_size(7)
-                row.cell(suit_symbols[0], align='C')
-                row.cell(suit_symbols[1], align='C')
-                row.cell(suit_symbols[2], align='C')
-                row.cell(suit_symbols[3], align='C')
+                row.cell(SUIT_SYMBOLS[0], align='C')
+                row.cell(SUIT_SYMBOLS[1], align='C')
+                row.cell(SUIT_SYMBOLS[2], align='C')
+                row.cell(SUIT_SYMBOLS[3], align='C')
                 row = table.row()
                 for i in range(4):
                     if i!=0:
@@ -154,6 +152,7 @@ def create_hand_record_pdf(pbn_paths, event, site):
     pdf = PDF(event, site)
     pdf.print_boards(results)
     pdf.output(fn)
+    os.close(fd)
     return fn
 
 

pbn_util.py

@@ -1,13 +1,14 @@
 from collections import defaultdict
 import logging
 import bridgebots
+from bridgebots import PlayerHand, Rank
 from pathlib import Path
 from datetime import datetime
 import pandas as pd
 import tempfile
-from collections import Counter
-from dds_util import get_result_table
+from dds_util import get_dd_tricks
 from typing import List, Dict
+import os
 
 
 DEALER_LIST = ['N', 'E', 'S', 'W']
@@ -128,24 +129,25 @@ def parse_pbn(file_path):
     return [(deal, board_records) for deal, board_records in records.items()]
 
 
-def create_single_pbn_string(
+def create_pbn_file(
         data: pd.DataFrame,
+        save_path = None,
         date=datetime.today(),
         board_no=1,
         event='',
         site='',
     ) -> str:
+    if not save_path:
+        fd, save_path = tempfile.mkstemp(suffix='.pbn')
+        os.close(fd)
+
     year = date.strftime("%y")
     month = date.strftime("%m")
     day = date.strftime("%d")
     date_print = day + "." + month + "." + year
     dealer = DEALER_LIST[(board_no-1) % 4]
     vulnerability=VULNERABILITY_LIST[(board_no-1) % 16]
-    deal = 'N:'
-    deal += ' '.join(
-        ['.'.join(data[col]) for col in data.columns[1:]]
-    ) # sss.hhh.ddd.ccc sss.hhh.ddd.ccc......
-    dd_tricks = get_result_table(deal)
+    deal = pbn_deal_string(data, dealer) # sss.hhh.ddd.ccc sss.hhh.ddd.ccc......
 
     file = ''
     file += ("%This PBN was generated by Bridge Hand Scanner\n")
@@ -156,8 +158,12 @@ def create_single_pbn_string(
     file += f'[Dealer "{dealer}"]\n'
     file += f'[Vulnerable "{vulnerability}"]\n'
     file += f'[Deal "{deal}"]\n'
-    file += dd_tricks
-    file += '\n'
+    file += pbn_optimum_table(deal)
+    file += '\n' # End of board
+
+    with open(save_path, 'w') as f:
+        f.write(file)
+
     return file
 
 def merge_pbn(pbn_paths):
@@ -178,55 +184,31 @@ def merge_pbn(pbn_paths):
                     f.write('\n')        
             f.write(v)
     return fn
-
-
-def validate_pbn(pbn_string):
+    
+def pbn_deal_string(df, dealer):
+    assert dealer in DEALER_LIST, f'Dealer {dealer} is not valid'
+    dealer_idx = DEALER_LIST.index(dealer)
+    dealer_list_rolled = DEALER_LIST[dealer_idx:] + DEALER_LIST[:dealer_idx]
+    deal = f'{dealer}:'
+    hand_reprs = []
+    for direction in dealer_list_rolled:
+        hand = PlayerHand.from_string_lists(*df[direction])
+        hand_reprs.append('.'.join([''.join([r.abbreviation() for r in hand.suits[suit]]) for suit in SUITS]))
+    deal += ' '.join(hand_reprs)
+    return deal
+
+DD_DIRECTIONS = ['N', 'S', 'E', 'W']
+DD_SUITS = ['NT', 'S', 'H', 'D', 'C']
+def pbn_optimum_table(pbn_deal_string):
     try:
-        deal, record = parse_single_pbn_record(pbn_string)
-    except AssertionError:
-        raise ValueError('Everyone should have 13 cards')
+        dd_tricks_string = get_dd_tricks(pbn_deal_string)
     except Exception as e:
-        raise Exception(e)
-    hands = deal.hands
-    duplicated = set()
-    missing = set()
-    validation_dict = {}
-    for suit in bridgebots.Suit:
-        cards = [hands[direction].suits[suit] for direction in hands]
-        # assert len(cards) == 13, 
-        cards = [c for c in sum([hands[direction].suits[suit] for direction in hands], [])]
-        duplicated.update([bridgebots.Card(suit,val) for val,cnt in Counter(cards).items() if cnt >1])
-
-        cards_set = set(cards)
-        missing.update([bridgebots.Card(suit,r) for r in bridgebots.Rank if not r in cards_set])
-
-    err_msg = ''
-    if len(duplicated) > 0:
-        err_msg += f'Duplicated cards: {duplicated}. '
-    if len(missing) > 0:
-        err_msg += f'Missing cards: {missing}. '
-
-    for direction in hands:
-        num_cards = len(hands[direction].cards)
-        if not num_cards == 13:
-            err_msg += '{direction.name} has {num_cards} cards. '
-    
-    if err_msg:
-        raise ValueError(err_msg)
-    
-def parse_dds_table(raw_list):
-    table = []
-    row = []
-    tempchar = ''
-    for x in raw_list:
-        if len(x) > 0:
-            tempchar += x[0]
-        else:
-            if len(tempchar) > 0:
-                row.append(tempchar)
-            tempchar = ''
-
-        if len(row) == 3:
-            table.append(row)
-            row = []
-    return table
+        print(e)
+        raise ValueError(e)
+    s = '[OptimumResultTable "Declarer;Denomination\\2R;Result\\2R"]\n'
+    for i, char in enumerate(dd_tricks_string):
+        direction = DD_DIRECTIONS[i//5]
+        suit = DD_SUITS[i%5]
+        tricks = int(char, 16)
+        s += f'{direction} {suit} {tricks}\n'
+    return s