def check_valid_split(set1_code, set2_code, set3_code): """[summary] Args: set1_code (str or tuple): [description] set2_code (str or tuple): [description] set3_code (str or tuple): [description] Returns: [type]: [description] """ if isinstance(set1_code, str): set1_code = ast.literal_eval(set1_code) set1_code = CardGroupCode(set1_code) if isinstance(set2_code, str): set2_code = ast.literal_eval(set2_code) set2_code = CardGroupCode(set2_code) if isinstance(set3_code, str): set3_code = ast.literal_eval(set3_code) set3_code = CardGroupCode(set3_code) if not set1_code.code or not set2_code.code or not set3_code.code: return False #print(set1_code) #print(set2_code) #print(set3_code) if (set1_code > set2_code) | (set2_code > set3_code): return False else: return True
def gen_code_combs_set(strategy=None, score_round_fac=1): """Generate code combs across sets, with optional filtering Args: strategy ([type]): [description] round_fac (int, optional): [description]. Defaults to 1. Returns: [type]: [description] """ if strategy is None: strategy = ChinesePokerPctileScoreStrategy() combs = [] existing_scores = [[], [], []] #prev_scores = (None, None, None) for code_set1, score_set1 in strategy.score_dicts[0].items(): print(score_set1) if round(score_set1/score_round_fac) in existing_scores[0]: continue univ_score1 = CardGroupCode.get_universal_score(code_set1) existing_scores[1] = [] for code_set2, score_set2 in strategy.score_dicts[1].items(): if (round(score_set2/score_round_fac) in existing_scores[1]) or (CardGroupCode(code_set2) < CardGroupCode(code_set1)): continue univ_score2 = CardGroupCode.get_universal_score(code_set2) existing_scores[2] = [] for code_set3, score_set3 in strategy.score_dicts[2].items(): if (round(score_set3/score_round_fac) in existing_scores[2]) or (CardGroupCode(code_set3) < CardGroupCode(code_set2)): continue univ_score3 = CardGroupCode.get_universal_score(code_set3) combs.append( ( code_set1, code_set2, code_set3, score_set1, score_set2, score_set3, univ_score1, univ_score2, univ_score3, ) ) existing_scores[2].append(round(score_set3/score_round_fac)) existing_scores[1].append(round(score_set2/score_round_fac)) existing_scores[0].append(round(score_set1/score_round_fac)) return combs
def classify_group(cards=None, group_code=None): """[summary] Args: cards (list): List of card strings """ classifier = CardGroupClassifier() if group_code is not None and cards is None: group_sorted_inds = None if isinstance(group_code, str): group_code = ast.literal_eval(group_code) if isinstance(group_code, tuple): group_code = CardGroupCode(group_code) else: group_code, group_sorted_inds = classifier.classify_card_group(cards) group_desc = classifier.get_code_description(group_code) return group_code, group_desc, group_sorted_inds
def play_hand(user_codes, com1_codes, com2_codes, com3_codes): codes = [user_codes, com1_codes, com2_codes, com3_codes] for cI, code_split in enumerate(codes): if isinstance(code_split[0], str): code_split = [ast.literal_eval(code) for code in code_split] codes[cI] = [CardGroupCode(code) for code in code_split] print(f'codes: {codes}') compare_combs = combinations(range(4), 2) comp_res = [[[] for _ in range(4)] for _ in range(4)] game_scores = [[-999 for _ in range(4)] for _ in range(4)] tot_game_scores = [0 for _ in range(4)] for i1, i2 in compare_combs: temp_comp_res = [None, None, None] for sI in range(3): if codes[i1][sI] > codes[i2][sI]: temp_comp_res[sI] = 1 elif codes[i1][sI] < codes[i2][sI]: temp_comp_res[sI] = -1 elif codes[i1][sI] == codes[i2][sI]: temp_comp_res[sI] = 0 comp_res[i1][i2] = temp_comp_res comp_res[i2][i1] = [-score for score in temp_comp_res] temp_game_score = sum(temp_comp_res) if abs(temp_game_score) == 3: temp_game_score *= 2 game_scores[i1][i2] = temp_game_score game_scores[i2][i1] = -temp_game_score tot_game_scores[i1] += temp_game_score tot_game_scores[i2] -= temp_game_score #print(comp_res) #print(game_scores) return comp_res, game_scores, tot_game_scores
def get_splits_data_for_single_game_and_seat_from_db( game_id, seat_id, cards=None, ): """[summary] Args: game_id (int): GameID seat_id (int): Between 1 and 4 cards (List): List of Card objects or card strings. """ if cards is None: hands = next(yield_dealt_hands_from_db(game_id, game_id))[1] cards = hands[seat_id - 1] elif isinstance(cards[0], str): deck = Deck() cards = deck.deal_custom_hand(cards) splits_table = GameC.CHINESE_POKER_db_consts['splits_table'] codes_table = GameC.CHINESE_POKER_db_consts['split_codes_table'] query = f'SELECT SplitSeqNo, SplitStr, + ' \ f'c1.L1Code AS S1L1Code, c1.L2Code AS S1L2Code, c1.L3Code AS S1L3Code, c1.L4Code AS S1L4Code, c1.L5Code AS S1L5Code, c1.L6Code AS S1L6Code, ' + \ f'c2.L1Code AS S2L1Code, c2.L2Code AS S2L2Code, c2.L3Code AS S2L3Code, c2.L4Code AS S2L4Code, c2.L5Code AS S2L5Code, c2.L6Code AS S2L6Code, ' + \ f'c3.L1Code AS S3L1Code, c3.L2Code AS S3L2Code, c3.L3Code AS S3L3Code, c3.L4Code AS S3L4Code, c3.L5Code AS S3L5Code, c3.L6Code AS S3L6Code ' + \ f'FROM {splits_table} s ' + \ f'JOIN {codes_table} c1 ON s.SplitID=c1.SplitID ' + \ f'JOIN {codes_table} c2 ON s.SplitID=c2.SplitID ' + \ f'JOIN {codes_table} c3 ON s.SplitID=c3.SplitID ' + \ f'WHERE s.GameID={game_id} AND s.SeatID={seat_id} ' + \ f'AND c1.SetNo=1 AND c2.SetNo=2 AND c3.SetNo=3' db_output, _ = DBF.select_query(query) hand_splits = [] for row in db_output: split_seq_no, split_str, s1c1, s1c2, s1c3, s1c4, s1c5, s1c6, s2c1, s2c2, s2c3, s2c4, s2c5, s2c6, s3c1, s3c2, s3c3, s3c4, s3c5, s3c6 = row split_cards, split_inds = _convert_split_str_to_split_cards( cards, split_str) s1code = [s1c1, s1c2, s1c3, s1c4, s1c5, s1c6] s2code = [s2c1, s2c2, s2c3, s2c4, s2c5, s2c6] s3code = [s3c1, s3c2, s3c3, s3c4, s3c5, s3c6] s1code = CardGroupCode([code for code in s1code if code is not None]) s2code = CardGroupCode([code for code in s2code if code is not None]) s3code = CardGroupCode([code for code in s3code if code is not None]) split_info_factory = ChinesePokerStrategy.ranked_split_info_factory split_info = split_info_factory( split_inds, split_cards, (s1code, s2code, s3code), None, None, None, None, None, split_seq_no, ) hand_splits.append(split_info) hand_splits = sorted(hand_splits, key=lambda x: x.SeqNo) return hand_splits
def yield_splits_data_from_db( self, start_game_id=None, end_game_id=None, ): #db_connector = DBF.connect_to_db() splits_table = GameC.CHINESE_POKER_db_consts['splits_table'] codes_table = GameC.CHINESE_POKER_db_consts['split_codes_table'] base_query = f'SELECT SplitSeqNo, SplitStr, + ' \ f'c1.L1Code AS S1L1Code, c1.L2Code AS S1L2Code, c1.L3Code AS S1L3Code, c1.L4Code AS S1L4Code, c1.L5Code AS S1L5Code, c1.L6Code AS S1L6Code, ' + \ f'c2.L1Code AS S2L1Code, c2.L2Code AS S2L2Code, c2.L3Code AS S2L3Code, c2.L4Code AS S2L4Code, c2.L5Code AS S2L5Code, c2.L6Code AS S2L6Code, ' + \ f'c3.L1Code AS S3L1Code, c3.L2Code AS S3L2Code, c3.L3Code AS S3L3Code, c3.L4Code AS S3L4Code, c3.L5Code AS S3L5Code, c3.L6Code AS S3L6Code ' + \ f'FROM {splits_table} s ' + \ f'JOIN {codes_table} c1 ON s.SplitID=c1.SplitID ' + \ f'JOIN {codes_table} c2 ON s.SplitID=c2.SplitID ' + \ f'JOIN {codes_table} c3 ON s.SplitID=c3.SplitID ' + \ f'WHERE s.GameID=%s AND s.SeatID=%s ' + \ f'AND c1.SetNo=1 AND c2.SetNo=2 AND c3.SetNo=3' for game_id in range(start_game_id, end_game_id + 1): hands = next(self.yield_dealt_hands_from_db(game_id, game_id))[1] game_splits = [] for seat_id in range(1, 5): query = base_query % (game_id, seat_id) cards = hands[seat_id - 1] db_output, _ = DBF.select_query(query) hand_splits = [] for row in db_output: split_seq_no, split_str, s1c1, s1c2, s1c3, s1c4, s1c5, s1c6, s2c1, s2c2, s2c3, s2c4, s2c5, s2c6, s3c1, s3c2, s3c3, s3c4, s3c5, s3c6 = row split_cards = self._convert_split_str_to_split_cards( cards, split_str) s1code = [s1c1, s1c2, s1c3, s1c4, s1c5, s1c6] s2code = [s2c1, s2c2, s2c3, s2c4, s2c5, s2c6] s3code = [s3c1, s3c2, s3c3, s3c4, s3c5, s3c6] s1code = CardGroupCode( [code for code in s1code if code is not None]) s2code = CardGroupCode( [code for code in s2code if code is not None]) s3code = CardGroupCode( [code for code in s3code if code is not None]) split_info_factory = ChinesePokerStrategy.ranked_split_info_factory split_info = split_info_factory( None, split_cards, (s1code, s2code, s3code), None, None, None, None, None, split_seq_no, ) hand_splits.append(split_info) game_splits.append(hand_splits) yield game_id, game_splits # TODO Convert each row to RankedSplitInfo named tuple # (Inds, Cards, Codes, ) return
def _load_single_scoring_table(self, scoring_method): return CardGroupCode.load_set_scoring_file(scoring_method)