poker-reinforcement-learning 0.1.8__py3-none-any.whl

poker_reinforcement_learning/__init__.py

@@ -0,0 +1,10 @@
+from .deck import *
+from .poker_host import *
+
+from .client import *
+from .server import *
+from .dummy_agent import *
+from .limp_agent import *
+
+
+__all__ = ["Client", "Server", "Deck", "Card", "LimpAgent", "DummyAgent"]

poker_reinforcement_learning/client.py

@@ -0,0 +1,220 @@
+# client.py
+import sys
+# Import deck from parent directory
+# sys.path.append("../")
+import socket
+import json
+from .poker_host import Player
+from .deck import Card
+
+class Client:
+    def __init__(self):
+        # initialize cliennt socket with localhost ip address on port 5555
+        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.host = "127.0.0.1"
+        self.port = 5555
+        self.client_socket.connect((self.host, self.port))
+        self.player_number = int(self.client_socket.recv(1024).decode())
+        self.player = Player(self.player_number)
+        self.player.chips *= self.player_number
+        print(f"You are Player {self.player_number}")
+
+    # Client messages Server
+    def send_message(self, message):
+        message = str(message)
+        self.client_socket.send(message.encode())
+
+    # Server messages Client
+    def receive_data(self):
+        data = self.client_socket.recv(1024).decode()
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            return data
+
+    # Logic to play the game 
+    def play_game(self):
+        def is_int(value):
+            try:
+                int(value)
+                return True
+            except ValueError:
+                return False
+        def is_str(value):
+            try:
+                str(value)
+                return True
+            except ValueError:
+                return False
+            
+        while True:
+            game_state = self.receive_data()
+            # Wait for start code
+            if isinstance(game_state, str) and game_state == "GAME STARTED":
+                print("Game has started!")
+                
+            
+            # Big Blind
+            elif isinstance(game_state, str) and ("BIG" in game_state):
+                self.player.chips -= 2
+                # TODO: Handle when player cannot afford big blind
+                if (self.player.chips < 0):
+                    self.player.chips = 0
+                
+            # Small Blind
+            elif isinstance(game_state, str) and ("SMALL" in game_state):
+                self.player.chips -= 1
+            
+            # Server gives chips back to player
+            elif isinstance(game_state, str) and ("GIVE" in game_state):
+                first_tilde_pos = game_state.find("~")
+                second_tilde_pos = game_state.find("~", first_tilde_pos + 1)
+                # Extract the value between the tilde characters
+                if first_tilde_pos != -1 and second_tilde_pos != -1:
+                    chips = game_state[first_tilde_pos + 1:second_tilde_pos]
+                    self.player.chips += int(chips)
+                    print(f"You got {chips} chips back!")
+                else:
+                    print("Tilde characters not found or value not present.")
+                
+            # If the data is the cards make bets
+            elif isinstance(game_state, dict):
+                self.player.chips = game_state['chips'][str(self.player_number)]
+                # print(f"Round: {game_state['round']}")
+                if (game_state['round'] == 'Showdown!'):
+                    self.print_showdown_cards(game_state)
+                    if self.player.player_number == game_state['winner']:
+                        self.player.chips += int(game_state['pot'])
+                    chips_str = "\033[92m{}\033[0m".format(str(self.player.chips))
+                    print(f"You now have {chips_str} chips!")
+                    continue
+
+                # Add cards into players hands if hand is empty 
+                if len(self.player.hand) == 0:
+                    for card_str in game_state["player_hand"]:
+                        card = Card.from_str(card_str)
+                        self.player.hand.append(card)
+
+                print("\nCurrent Cards:")
+                self.print_cards(game_state)
+                # Active player makes their move
+                if game_state['current_player'] == self.player_number:
+                    # Game Info
+                    print(f"Current Player: Player {game_state['current_player']}", end=" | ")
+                    print(f"Current Dealer: Player {game_state['current_dealer']}", end=" | ")
+                    print(f"Current Pot: {game_state['pot']}")
+                    chips_str = "\033[92m{}\033[0m".format(str(self.player.chips))
+                    print(f"You have {chips_str} chips")
+                    if (game_state['current_bet'] == 0): 
+                        print("What would you like to do?\nType 1 to check, 2 to raise, and 3 to fold")
+                    if (game_state['current_bet'] > 0): 
+                        print("What would you like to do?\nType 1 to call, 2 to raise, and 3 to fold")
+                    print("Bets:")
+                    print("| ",end="")
+                    for player,bet in game_state['bets'].items():
+                        if bet < 0:
+                            bet = 0
+                        print(f"Player {player}: {bet} chips", end=" | ")
+                    print(f"Current Bet: {game_state['current_bet']} |")
+
+                    # Get players choice
+                    action = input("Enter your move (1-3): ")
+                    while ((not is_int(action)) or (int(action) < 1) or (int(action) > 3)):
+                        print("Invalid choice.")
+                        action = input("Enter your move (1-3): ")
+                    
+                    self.send_message(action)
+                    # TODO: Handle when player cannot bet but tries to anyways
+                    if int(action) == 2:
+                        bet = input("Enter your bet:")
+                        
+                        # Player cannot make bet if the bet is not a number, 
+                        while ((not is_int(bet)) or (int(bet) < 0) or ((int(bet) + game_state['current_bet']) > self.player.chips)):
+                            print("Invalid bet.")
+                            bet = input("Enter your bet:")
+                        self.player.chips -= int(bet) + game_state['current_bet']
+                        self.send_message(bet)
+                    elif int(action) == 1:
+                        if game_state['bets'][str(self.player.player_number)] >= 0:
+                            self.player.chips += game_state['bets'][str(self.player.player_number)]
+                            self.player.chips -= int(game_state['current_bet'])
+                            
+                    print()
+                else:
+                    print("Waiting for the other player's move...")
+            # If the move is invalid, the player is prompted again
+            elif isinstance(game_state, str) and game_state == "INVALID_MOVE":
+                print("Invalid move. Please try again.")
+                continue
+            
+            elif isinstance(game_state, str) and ("WIN" in game_state):
+                print("Congratulations! You won!")
+                self.player.hand = []
+
+                action = input("Do you want to play again? (y/n)")
+                action = action.lower()
+                while not is_str(action) or (action != "y" and action != "n"):
+                    print('invalid entry')
+                    action = input("Do you want to play again? (y/n)")
+                    action = action.lower()
+                self.send_message(action)
+                
+            elif isinstance(game_state, str) and ("LOSS" in game_state):
+                print("Sorry, you lost...")
+                self.player.hand = []
+                
+                action = input("Do you want to play again? (y/n)")
+                action = action.lower()
+                while not is_str(action) or (action != "y" and action != "n"):
+                    print('invalid entry')
+                    action = input("Do you want to play again? (y/n)")
+                    action = action.lower()
+                self.send_message(action)
+                
+            # Break code when the game ends
+            elif isinstance(game_state, str) and ("END" in game_state):
+                print("Game ended.")
+                break
+            elif isinstance(game_state, str):
+                print(game_state)
+                
+    # Close client socket
+    def close_connection(self):
+        self.client_socket.close()
+
+    # Helper methods for formatting
+    @staticmethod
+    def print_cards(game_state):
+        print(f"Your Hand:")
+        print("| ", end="")
+        for card_str in game_state["player_hand"]:
+            card = Card.from_str(card_str)
+            print(card.print_card(),end = " | ")
+        print("\n---------------------------")
+        if (len(game_state['community_cards']) > 0):
+            print(f"Community Cards:")
+            print("| ", end="")
+            for card_str in game_state["community_cards"]:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+        print()
+    @staticmethod
+    def print_showdown_cards(game_state):
+        for player, hand in game_state['players_hand'].items():
+            print(f"Player {player}'s Hand:")
+            print("| ", end="")
+            for card_str in hand:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+            print("\n---------------------------")
+        if (len(game_state['community_cards']) > 0):
+            print(f"Community Cards:")
+            print("| ", end="")
+            for card_str in game_state["community_cards"]:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+        print()
+        
+
+
+        

poker_reinforcement_learning/deck.py

@@ -0,0 +1,99 @@
+import random
+
+class Card:
+    
+
+    def __init__(self, name, color, suit):
+        self.name = name
+        self.color = color
+        self.suit = suit
+        self.value = self.calculate_poker_value()
+    
+    @classmethod
+    def from_str(cls, card_str):
+        # Assuming the format of card_str is "Name of Suit (Color)"
+        parts = card_str.split()
+        name = parts[0]
+        suit = parts[2]
+        color = parts[3][1:-1]  # Remove parentheses from color
+
+        return cls(name, color, suit)
+
+    def calculate_blackjack_value(self):
+        if self.name in ['Jack', 'Queen', 'King']:
+            return 10
+        elif self.name == 'Ace':
+            return 1
+        else:
+            return int(self.name)
+        
+    def calculate_poker_value(self):
+        if self.name == 'Jack':
+            return 11
+        elif self.name == 'Queen':
+            return 12
+        elif self.name == 'King':
+            return 13
+        elif self.name == 'Ace':
+            return 14
+        else:
+            return int(self.name)
+
+    def __str__(self):
+        return f"{self.name} of {self.suit} ({self.color})"
+    
+    def print_card(self):
+        symbols = {"Spade": "♠", "Clover":"♣","Heart":"♥","Diamond":"♦"}
+        def print_black(text):
+            return "\033[30m{}\033[0m".format(text)
+        def print_red(text):
+            return "\033[91m{}\033[0m".format(text)
+        if (self.color =="black"):
+            return f"{self.name} {print_black(symbols[self.suit])}"
+        if (self.color =="red"):
+            return f"{self.name} {print_red(symbols[self.suit])}"
+class Deck:
+    def __init__(self):
+        self.cards = []
+        self.populate_deck()
+
+    def populate_deck(self):
+        names = ['Ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King']
+        suits = ['Diamond', 'Clover', 'Spade', 'Heart']
+
+        for suit in suits:
+            for name in names:
+                color = 'red' if suit in ['Diamond', 'Heart'] else 'black'
+                card = Card(name, color, suit)
+                self.cards.append(card)
+
+    def shuffle(self):
+        random.shuffle(self.cards)
+
+    def deal_card(self):
+        if len(self.cards) > 0:
+            return self.cards.pop()
+        else:
+            print("No more cards in the deck.")
+            return None
+
+def combine_decks(deck1, deck2):
+    combined_deck = Deck()
+    combined_deck.cards = deck1.cards + deck2.cards
+    return combined_deck
+
+   
+if __name__ == "__main__":
+    deck1 = Deck()
+    deck2 = Deck()
+
+    # deck1.shuffle()
+    deck2.shuffle()
+
+    combined_deck = combine_decks(deck1, deck2)
+
+    print("Deck:")
+    for _ in range(52):
+        card = deck1.deal_card()
+        if card:
+            print(card)

poker_reinforcement_learning/dummy_agent.py

@@ -0,0 +1,240 @@
+# client.py
+import sys
+# Import deck from parent directory
+import socket
+import json
+from .poker_host import Player
+from .deck import Card
+
+
+"""
+Limp Agent:
+    This agent participates based on the concept of "limping" through games. Essentially, the agent will simply match bets so that it can stay in the game but not increase bets to try and gain an advantage. 
+    In the poker community, this is quite looked down upon. It kills the excitement of the game and becomes "predictable" and drags on games where players with bad hands should fold. 
+    This is a perfect default agent for our purposes! It's strategically weak, extremely easy to implement, and if bugs are thrown I know that it's not because of internal logic. 
+Decision Making Logic:
+    The decision making function will return 1 every time to call every hand. 
+"""
+class DummyAgent:
+    def __init__(self, logic):
+        # initialize cliennt socket with localhost ip address on port 5555
+        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.host = "127.0.0.1"
+        self.port = 5555
+        self.client_socket.connect((self.host, self.port))
+        self.player_number = int(self.client_socket.recv(1024).decode())
+        self.player = Player(self.player_number)
+        self.player.chips *= self.player_number
+        print(f"You are Player {self.player_number}")
+
+        self.logic = logic
+
+    # Client messages Server
+    def send_message(self, message):
+        message = str(message)
+        self.client_socket.send(message.encode())
+
+    # Server messages Client
+    def receive_data(self):
+        data = self.client_socket.recv(1024).decode()
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            return data
+
+    # Logic to play the game 
+    def play_game(self):
+        def is_int(value):
+            try:
+                int(value)
+                return True
+            except ValueError:
+                return False
+        def is_str(value):
+            try:
+                str(value)
+                return True
+            except ValueError:
+                return False
+            
+        while True:
+            game_state = self.receive_data()
+            # Wait for start code
+            if isinstance(game_state, str) and game_state == "GAME STARTED":
+                print("Game has started!")
+                
+            
+            # Big Blind
+            elif isinstance(game_state, str) and ("BIG" in game_state):
+                self.player.chips -= 2
+                # TODO: Handle when player cannot afford big blind
+                if (self.player.chips < 0):
+                    self.player.chips = 0
+                
+            # Small Blind
+            elif isinstance(game_state, str) and ("SMALL" in game_state):
+                self.player.chips -= 1
+            
+            # Server gives chips back to player
+            elif isinstance(game_state, str) and ("GIVE" in game_state):
+                first_tilde_pos = game_state.find("~")
+                second_tilde_pos = game_state.find("~", first_tilde_pos + 1)
+                # Extract the value between the tilde characters
+                if first_tilde_pos != -1 and second_tilde_pos != -1:
+                    chips = game_state[first_tilde_pos + 1:second_tilde_pos]
+                    self.player.chips += int(chips)
+                    print(f"You got {chips} chips back!")
+                else:
+                    print("Tilde characters not found or value not present.")
+                
+            # If the data is the cards make bets
+            elif isinstance(game_state, dict):
+                self.player.chips = game_state['chips'][str(self.player_number)]
+                # print(f"Round: {game_state['round']}")
+                if (game_state['round'] == 'Showdown!'):
+                    self.print_showdown_cards(game_state)
+                    if self.player.player_number == game_state['winner']:
+                        self.player.chips += int(game_state['pot'])
+                    chips_str = "\033[92m{}\033[0m".format(str(self.player.chips))
+                    print(f"You now have {chips_str} chips!")
+                    continue
+
+                # Add cards into players hands if hand is empty 
+                if len(self.player.hand) == 0:
+                    for card_str in game_state["player_hand"]:
+                        card = Card.from_str(card_str)
+                        self.player.hand.append(card)
+
+                print("\nCurrent Cards:")
+                self.print_cards(game_state)
+                # Active player makes their move
+                if game_state['current_player'] == self.player_number:
+                    # Game Info
+                    print(f"Current Player: Player {game_state['current_player']}", end=" | ")
+                    print(f"Current Dealer: Player {game_state['current_dealer']}", end=" | ")
+                    print(f"Current Pot: {game_state['pot']}")
+                    chips_str = "\033[92m{}\033[0m".format(str(self.player.chips))
+                    print(f"You have {chips_str} chips")
+                    if (game_state['current_bet'] == 0): 
+                        print("What would you like to do?\nType 1 to check, 2 to raise, and 3 to fold")
+                    if (game_state['current_bet'] > 0): 
+                        print("What would you like to do?\nType 1 to call, 2 to raise, and 3 to fold")
+                    print("Bets:")
+                    print("| ",end="")
+                    for player,bet in game_state['bets'].items():
+                        if bet < 0:
+                            bet = 0
+                        print(f"Player {player}: {bet} chips", end=" | ")
+                    print(f"Current Bet: {game_state['current_bet']} |")
+
+                    # Get players choice
+                    action, bet = self.make_decision(game_state=game_state, logic=self.logic)
+                    while ((not is_int(action)) or (int(action) < 1) or (int(action) > 3)):
+                        print("Invalid choice.")
+                        raise Exception("Dummy Agent chose an invalid action.")
+                        action = self.make_decision(game_state=game_state)
+                    
+                    self.send_message(action)
+                    # TODO: Handle when player cannot bet but tries to anyways
+                    if int(action) == 2:
+                        
+                        # Player cannot make bet if the bet is not a number, 
+                        while ((not is_int(bet)) or (int(bet) < 0) or ((int(bet) + game_state['current_bet']) > self.player.chips)):
+                            print("Invalid bet.")
+                            raise Exception("Invalid Bet has occurred from automated bot")
+                        self.player.chips -= int(bet) + game_state['current_bet']
+                        self.send_message(bet)
+
+                    # Action should always be 1
+                    if int(action) == 1:
+                        print("AI Called!!!")
+                        if game_state['bets'][str(self.player.player_number)] >= 0:
+                            self.player.chips += game_state['bets'][str(self.player.player_number)]
+                            self.player.chips -= int(game_state['current_bet'])
+                            
+                    print()
+                else:
+                    print("Waiting for the other player's move...")
+            # If the move is invalid, the player is prompted again
+            elif isinstance(game_state, str) and game_state == "INVALID_MOVE":
+                print("Invalid move. Please try again.")
+                continue
+            
+            elif isinstance(game_state, str) and ("WIN" in game_state):
+                print("Congratulations! You won!")
+                self.player.hand = []
+
+                action = input("Do you want to play again? (y/n)")
+                action = action.lower()
+                while not is_str(action) or (action != "y" and action != "n"):
+                    print('invalid entry')
+                    action = input("Do you want to play again? (y/n)")
+                    action = action.lower()
+                self.send_message(action)
+                
+            elif isinstance(game_state, str) and ("LOSS" in game_state):
+                print("Sorry, you lost...")
+                self.player.hand = []
+                
+                action = input("Do you want to play again? (y/n)")
+                action = action.lower()
+                while not is_str(action) or (action != "y" and action != "n"):
+                    print('invalid entry')
+                    action = input("Do you want to play again? (y/n)")
+                    action = action.lower()
+                self.send_message(action)
+                
+            # Break code when the game ends
+            elif isinstance(game_state, str) and ("END" in game_state):
+                print("Game ended.")
+                break
+            elif isinstance(game_state, str):
+                print(game_state)
+               
+    # Close client socket
+    def close_connection(self):
+        self.client_socket.close()
+
+    @staticmethod
+    def make_decision(game_state, logic):
+        return logic(game_state)
+    
+
+    # Helper methods for formatting
+    @staticmethod
+    def print_cards(game_state):
+        print(f"Your Hand:")
+        print("| ", end="")
+        for card_str in game_state["player_hand"]:
+            card = Card.from_str(card_str)
+            print(card.print_card(),end = " | ")
+        print("\n---------------------------")
+        if (len(game_state['community_cards']) > 0):
+            print(f"Community Cards:")
+            print("| ", end="")
+            for card_str in game_state["community_cards"]:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+        print()
+    @staticmethod
+    def print_showdown_cards(game_state):
+        for player, hand in game_state['players_hand'].items():
+            print(f"Player {player}'s Hand:")
+            print("| ", end="")
+            for card_str in hand:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+            print("\n---------------------------")
+        if (len(game_state['community_cards']) > 0):
+            print(f"Community Cards:")
+            print("| ", end="")
+            for card_str in game_state["community_cards"]:
+                card = Card.from_str(card_str)
+                print(card.print_card(),end = " | ")
+        print()
+        
+
+
+        
+
+