def test_hands_without_suit(self):
assert Range("AK 48").hands == (
Hand("84o"),
Hand("84s"),
Hand("AKo"),
Hand("AKs"),
)
def main():
print('Welcome to Poker Scorer')
card_array = [
Card(value, suit) for suit in CARD_SUITS for value in CARD_VALUES
]
deck = Deck(card_array)
poker_game = Poker(deck)
hand_1 = Hand([
Card('3', 'hearts'),
Card('4', 'hearts'),
Card('5', 'diamonds'),
Card('4', 'clubs'),
Card('2', 'hearts')
])
hand_2 = Hand([
Card('2', 'spades'),
Card('4', 'spades'),
Card('5', 'diamonds'),
Card('4', 'diamonds'),
Card('2', 'hearts')
])
poker_game.add_single_hand_to_game(hand_1)
poker_game.add_single_hand_to_game(hand_2)
print(poker_game.compare_two_hands())
def train(self, *, iterations):
deck = Deck()
self.iteration = 1
self.cumulative_stack_utilities = [
0 for stack_size in range(TOTAL_STACKS +
1) # (stack_size) / TOTAL_STACKS
]
for self.iteration in range(1, iterations):
for p0_stack in range(1, TOTAL_STACKS):
p1_stack = TOTAL_STACKS - p0_stack
deck.reset()
deck.shuffle()
p0_hand = Hand([deck.pop(), deck.pop()])
p1_hand = Hand([deck.pop(), deck.pop()])
big_blind = min(BIG_BLIND, p0_stack, p1_stack)
self.cumulative_stack_utilities[p0_stack] += self.cfr(
deck,
(p0_hand, p1_hand),
EMPTY_HISTORY,
(p0_stack, p1_stack),
(SMALL_BLIND, big_blind),
(1, 1),
)
# print(f"Average game value: {utility/iterations}")
print(f"Iterations: {iterations}")
print("Stack size,Utility")
for stack_size, utility in enumerate(self.cumulative_stack_utilities):
print(f"{stack_size},{self.get_average_stack_utility(stack_size)}")
for node in map(lambda node: node[1], sorted(self.node_map.items())):
print(node)
def _create_players(self, number):
names = Names()
self.hide_player_buttons()
self._root.update()
deck = CardDeck()
cards = Card.create_cards()
deck.add_cards(cards)
hand = Hand()
player = Player(f"Player", hand)
self._players.append(player)
human = Human(player=player, gui=self)
for i in range(number):
hand = Hand()
# player = Player(f"Opponent {i + 1}", hand)
player = Player(names.get_random_name(), hand)
self._players.append(player)
ai = AI(player=player)
self.hide_player_buttons()
for player in self._players:
player.add_chips(60)
game = GameRound(players=self._players, deck=deck, gui=self)
# game.set_game_qty(game_qty=10)
game.set_game_qty(infinite=True)
game.play()
self.stop()
def test_hand_storing():
deck = Deck()
hand = Hand()
for i in range(4):
hand.receive(deck.deal())
sorted_hand = hand.sorted()
for i in range(1, len(hand)):
assert sorted_hand[i] >= sorted_hand[i - 1]
def test_receives_and_stores_cards(self):
ace_of_spades = Card(rank='Ace', suit='Diamonds')
two_of_clubs = Card(rank='2', suit='Clubs')
cards = [ace_of_spades, two_of_clubs]
hand = Hand()
hand.add_cards(cards)
self.assertEqual(hand.cards, [two_of_clubs, ace_of_spades])
def test_offsuit_minus(self):
assert Range("76o-").hands == (
Hand("72o"),
Hand("73o"),
Hand("74o"),
Hand("75o"),
Hand("76o"),
)
def test_suited_minus(self):
assert Range("76s-").hands == (
Hand("72s"),
Hand("73s"),
Hand("74s"),
Hand("75s"),
Hand("76s"),
)
def test_dash_offsuit(self):
assert Range("J8o-J4o").hands == (
Hand("J4o"),
Hand("J5o"),
Hand("J6o"),
Hand("J7o"),
Hand("J8o"),
)
def test_dash_suited(self):
assert Range("J8s-J4s").hands == (
Hand("J4s"),
Hand("J5s"),
Hand("J6s"),
Hand("J7s"),
Hand("J8s"),
)
def test__is_not_straight():
hand = Hand()
hand.receive(Card(12, 'heart'))
hand.receive(Card(11, 'spade'))
hand.receive(Card(10, 'club'))
hand.receive(Card(9, 'diamond'))
hand.receive(Card(8, 'heart'))
assert is_straight(hand)
def test_is_straight():
hand = Hand()
hand.receive(Card(12, 'club'))
hand.receive(Card(8, 'heart'))
hand.receive(Card(8, 'spade'))
hand.receive(Card(8, 'club'))
hand.receive(Card(11, 'spade'))
assert not is_straight(hand)
def test_shows_all_its_cards_in_technical_representation(self):
cards = [
Card(rank="Ace", suit="Diamonds"),
Card(rank="7", suit="Clubs")
]
hand = Hand()
hand.add_cards(cards)
self.assertEqual(repr(hand), "7 of Clubs, Ace of Diamonds")
def hands_from_text(text):
p1_cards = text[:14]
p2_cards = text[15:].strip()
logger.debug(f"cards: {p1_cards}/{p2_cards}")
return (
Hand.from_string(p1_cards),
# use strip() to remove he newline (if present)
Hand.from_string(p2_cards),
)
def test_hand_return_three_of_kind(self):
hand = [
Card("Ace", "Clubs"),
Card("Ace", "Diamonds"),
Card("Ace", "Spades"),
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Three of a Kind")
def test_hand_picking():
deck = Deck()
original_size = len(deck)
hand = Hand()
card = deck.deal()
hand.receive(card)
assert deck.dealed[0] == hand[0]
assert len(hand) == 1
assert len(deck) == original_size - 1
def test_receive_and_stores_cards(self):
ace_of_spades = Card(rank="Ace", suit="Spades")
six_of_clubs = Card(rank="6", suit="Clubs")
cards = [ace_of_spades, six_of_clubs]
hand = Hand()
hand.add_cards(cards)
self.assertEqual(hand.cards, [six_of_clubs, ace_of_spades])
def test_hand_return_two_pair(self):
hand = [
Card("Ace", "Clubs"),
Card("Ace", "Diamonds"),
Card("7", "Clubs"),
Card("7", "Diamonds")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Two Pair")
def test_hand_value_pair(self):
hand = [
Card("2", "Clubs"),
Card("2", "Diamonds"),
Card("8", "Clubs"),
Card("7", "Diamonds")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.score, (200 + sum([1, 1])))
def test_figures_out_pair_is_best_rank(self):
cards = [
Card(rank="Ace", suit="Spades"),
Card(rank="Ace", suit="Clubs")
]
hand = Hand()
hand.add_cards(cards=cards)
self.assertEqual(hand.best_rank(), "Pair")
def test_hand_return_four_of_kind(self):
hand = [
Card("Ace", "Clubs"),
Card("Ace", "Diamonds"),
Card("Ace", "Hearts"),
Card("Ace", "Spades")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Four of a Kind")
def test_figures_out_high_card_is_best_rank(self):
cards = [
Card(rank="Ace", suit="Spades"),
Card(rank="7", suit="Diamonds")
]
hand = Hand()
hand.add_cards(cards=cards)
self.assertEqual(hand.best_rank(), "High Card")
def test_figures_out_best_hand_when_flush(self):
cards = [
Card(rank=rank, suit="Hearts")
for rank in ["2", "5", "8", "10", "Ace"]
]
hand = Hand()
hand.add_cards(cards=cards)
self.assertEqual(hand.best_rank(), "Flush")
def test_does_not_deem_two_consecutive_cards_as_straight(self):
cards = [
Card(rank="6", suit="Hearts"),
Card(rank="7", suit="Diamonds"),
]
hand = Hand()
hand.add_cards(cards=cards)
self.assertEqual(hand.best_rank(), "High Card")
def test_hand_cards_are_sorted(self):
cards = [
Card(rank = "5", suite = "hearts"),
Card(rank = "Ace", suite = "clubs"),
Card(rank = "King", suite = "clubs"),
]
hand = Hand()
hand.add_cards(cards)
self.assertEqual(
hand.cards,
[
Card(rank = "5", suite = "hearts"),
Card(rank = "King", suite = "clubs"),
Card(rank = "Ace", suite = "clubs")
]
)
def test_best_Rank(self):
cards = [
Card(rank = "5", suite = "hearts"),
Card(rank = "Ace", suite = "clubs"),
Card(rank = "King", suite = "clubs"),
]
hand = Hand()
hand.add_cards(cards)
self.assertEqual(
hand.best_rank(),
(9,"Highest card",[Card(rank = "Ace", suite = "clubs")])
)
def test_nothing_is_nothing():
hand = Hand()
hand.receive(Card(12, 'heart'))
hand.receive(Card(10, 'club'))
hand.receive(Card(8, 'diamond'))
hand.receive(Card(6, 'spade'))
hand.receive(Card(4, 'heart'))
for score in SCORES:
if score.get('name', '') != 'nothing':
assert not score['tester'](hand)
assert is_nothing(hand)
def test_hand_return_full_house(self):
hand = [
Card("Ace", "Clubs"),
Card("Ace", "Diamonds"),
Card("Ace", "Hearts"),
Card("7", "Spades"),
Card("7", "Spades")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Full House")
def test_hand_return_flush(self):
hand = [
Card("2", "Diamonds"),
Card("4", "Diamonds"),
Card("6", "Diamonds"),
Card("8", "Diamonds"),
Card("10", "Diamonds")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Flush")
def test_hand_return_straight(self):
hand = [
Card("2", "Clubs"),
Card("3", "Diamonds"),
Card("4", "Hearts"),
Card("5", "Diamonds"),
Card("6", "Diamonds")
]
cards = Hand()
cards.add_cards(hand)
self.assertEqual(cards.hand, "Straight")
def test_to_check_technical_representation_of_hand(self):
hand = Hand()
cards = [
Card(rank = "7", suite = "spades"),
Card(rank = "Ace", suite = "clubs")
]
hand.add_cards(cards)
self.assertEqual(
repr(hand),
"7 of spades, Ace of clubs"
)
