Chess_game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "081c87db",
   "metadata": {},
   "source": [
    "# Python Challenge: Chess Game Analysis\n",
    "\n",
    "This project analyzes virtual chess games that are stored in a `.pgn` format. This file contains a set of game moves for each chess game. The goal is to extract the black piece moves and white piece moves separately and visualise the 10 most common moves throughout the game file.\n",
    "\n",
    "## 1. Importing the Libraries\n",
    "\n",
    "Let us import the necessary libraries required for this task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e514bb9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing all the necessary libraries\n",
    "import re\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cb91a1",
   "metadata": {},
   "source": [
    "## 2. Code Operations\n",
    "\n",
    "The below description lists the set of operations that were performed to achieve the final visualisation in the form of a bar chart. The bulk of these operations are contained in a Python class that can be reused in another code as required.\n",
    "\n",
    "**NOTE: Please go through the below text to better understand the tasks being performed by the code\n",
    "and the information being derived from the final plot.**\n",
    "\n",
    "Code Description: \n",
    "\n",
    "The sequence of execution for different pieces of code in this project is given as follows:\n",
    "\n",
    "### 2.1 regex_filter\n",
    "\n",
    "1. Read from the .pgn file.\n",
    "2. Identify game metadata format.\n",
    "3. Remove game metadata.\n",
    "4. Identify game score format at the end of each game.\n",
    "5. Remove the game score.\n",
    "6. Write clean file to game_strings.txt.\n",
    "\n",
    "### 2.2 moves_generator\n",
    "\n",
    "7. Read from game_strings.txt.\n",
    "8. Extract white moves for each game.\n",
    "9. Extract black moves for each game.\n",
    "9. Write game files for white moves and black moves.\n",
    "10. Print the number of files which have been created.\n",
    "\n",
    "\n",
    "### 2.3 first_move\n",
    "\n",
    "11. Read from game_strings.txt.\n",
    "12. Extract white first moves. \n",
    "13. Extract black first moves.\n",
    "14. Extract unique white first moves.\n",
    "15. Count all white first moves.\n",
    "16. Extract unique black first moves.\n",
    "17. Count all black first moves.\n",
    "\n",
    "### 2.4 chess_moves_plot\n",
    "\n",
    "18. Call the method first_move.\n",
    "19. Retrieve the tuple containing the two data frames.\n",
    "20. Separate the two data frames from the tuple.\n",
    "21. Add a new column to each data frame to identify the type of move\n",
    "22. Merge the two data frames into one.\n",
    "23. Sort the combined data frame in descending order.\n",
    "24. Extract the top 10 first moves from the dataframe.\n",
    "25. Define a colour palette for the legend and to identify a chess move as black or white.\n",
    "26. Plot the top 10 first moves on a bar plot.\n",
    "27. Label the x-axis and y-axis.\n",
    "28. Specify the title for the plot.\n",
    "29. Add colours and a legend to the plot.\n",
    "30. Display the plot.\n",
    "\n",
    "### 2.5 Calling the Methods of the Class ChessGame (Driver Code):\n",
    "\n",
    "1. Ask the user to input the name of a valid .pgn file to be read. Only existing .pgn files are accepted.\n",
    "2. Create an instance of the object of class ChessGame with the .pgn file.\n",
    "3. Call the regex_filter method with the above instance.\n",
    "4. Close the .pgn file to release the read lock on the file.\n",
    "5. Create a second instance of the object of class ChessGame with the newly created clean game.\n",
    "strings file.\n",
    "6. Call the moves_generator method with the above instance.\n",
    "7. Close the game strings file to release the read lock on the file\n",
    "8. Create a third instance of the object of class ChessGame with the same clean game strings file.\n",
    "9. Call the chess_moves_plot method with the above instance.\n",
    "10. Close the game strings file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cacc3b75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the name of the file to be parsed along with its extension( Example: chess_game.pgn): chess_game.pgn\n",
      "Success! Game Strings File Created in Current Directory\n",
      "White moves files: 2110\n",
      "Black moves files: 2110\n",
      "Total number of files created: 4220\n",
      "Success!\n",
      "\n",
      "  Move  Number_of_Occurrences   Type\n",
      "0   d4                    907  White\n",
      "1   e4                    828  White\n",
      "2  Nf6                    787  Black\n",
      "3   c5                    504  Black\n",
      "4   d5                    287  Black\n",
      "5   e5                    246  Black\n",
      "6  Nf3                    186  White\n",
      "7   c4                    179  White\n",
      "8   e6                    113  Black\n",
      "9   g6                     57  Black\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Defining a class called ChessGame. All the required operations will be conducted inside this class\n",
    "class ChessGame:\n",
    "\n",
    "    # Defining the object of class ChessGame using the init constructor method\n",
    "    def __init__(self, chess_games):\n",
    "        self.chess_games = chess_games\n",
    "\n",
    "    # ################### 3.2: Filtering the Game Data ################### #\n",
    "\n",
    "    # Defining a method to filter the .pgn game file\n",
    "    def regex_filter(self):\n",
    "\n",
    "        # Defining three different regex patterns to remove the game metadata and final scores\n",
    "        # from the chess.pgn file\n",
    "        pattern = re.compile(r\"\\[(.*?)\\]\")  # Regex pattern to isolate the game metadata\n",
    "        pattern2 = re.compile(r\"\\d+/\\d+-\\d+/\\d+\")  # Regex pattern if the final score is a draw (1/2-1/2)\n",
    "        pattern3 = re.compile(r\"\\d+-\\d+\")  # Regex pattern if the final score is a win (1-0) or a loss (0-1)\n",
    "\n",
    "        # Defining a file to write the clean game strings to\n",
    "        clean_game_file = open('game_string.txt', 'w')\n",
    "\n",
    "        # Reading each line of the .pgn file being\n",
    "        lines = self.chess_games.readlines()\n",
    "\n",
    "        # Join the elements of the above iterable into one string and remove the chess games\n",
    "        # metadata using the regex pattern defined for it\n",
    "        my_string = ' '.join([line.strip() for line in lines if not re.match(pattern, line)])\n",
    "\n",
    "        # The above join operation has created a whitespace to the left of the string so this\n",
    "        # step will remove that whitespace\n",
    "        my_string = my_string.lstrip()\n",
    "\n",
    "        # Putting the partially clean game string in a list\n",
    "        # Each game string will be an individual element in this list\n",
    "        regex_list = my_string.split('   ')\n",
    "\n",
    "        # Check the partially cleaned list of game strings by uncommenting the next line.\n",
    "        # This step is optional\n",
    "        # print(regex_list)\n",
    "\n",
    "        # For loop to remove the score at the end of each game using two different regex\n",
    "        # patterns and write each clean game string to each line of the game_string.txt file\n",
    "        for element in range(0, len(regex_list)):\n",
    "            regex_list[element] = re.sub(pattern2, \"\", regex_list[element])\n",
    "            regex_list[element] = re.sub(pattern3, \"\", regex_list[element])\n",
    "            regex_list[element] = regex_list[element].rstrip()\n",
    "            clean_game_file.writelines(regex_list[element] + \"\\n\")\n",
    "\n",
    "        # Printing confirmation of the game strings file being created successfully\n",
    "        print(f\"Success! Game Strings File Created in Current Directory\")\n",
    "\n",
    "        # Close the game_string.txt file\n",
    "        clean_game_file.close()\n",
    "\n",
    "        # Check the fully cleaned list of game strings by uncommenting the next line.\n",
    "        # This step is optional\n",
    "        # print(regex_list)\n",
    "\n",
    "    # ################### 3.3: Sub Files ################### #\n",
    "\n",
    "    # Defining a method to create two separate moves files for each game\n",
    "    def moves_generator(self):\n",
    "\n",
    "        # Read each line of the newly created game_strings file passed as an instance\n",
    "        # of the object of class ChessGame\n",
    "        lines = self.chess_games.readlines()\n",
    "\n",
    "        # Defining a regex pattern to remove trailing numbers for each move pair.\n",
    "        # For eg. 1.e4 d3 to e4 d3\n",
    "        pattern4 = re.compile(r\"\\d{1,3}\\.\")\n",
    "\n",
    "        # Defining a for loop to access each line of the file\n",
    "        for line in range(0, len(lines)):\n",
    "            # Capture the above defined regex pattern and remove it from every\n",
    "            # line in the file\n",
    "            lines[line] = re.sub(pattern4, \"\", lines[line])\n",
    "\n",
    "            # Converting each game string into its individual list. Each list\n",
    "            # will contain individual game moves as list elements\n",
    "            game = lines[line].split()\n",
    "\n",
    "            # Incrementing the index value by 1 so that the game number in the\n",
    "            # white moves and black moves files starts from 1 instead of 0\n",
    "            game_number = line + 1\n",
    "\n",
    "            # Splitting the games into two separate lists containing only the white moves\n",
    "            # and black moves respectively\n",
    "            # Source: https://realpython.com/python-enumerate/\n",
    "            white = [move for j, move in enumerate(game) if j % 2 == 0]\n",
    "            black = [move for j, move in enumerate(game) if j % 2 != 0]\n",
    "\n",
    "            # Writing the list of white moves for each game to their respective game files\n",
    "            with open(f\"{game_number}w.txt\", 'w') as white_moves:\n",
    "                white_moves.write(' '.join(white))\n",
    "\n",
    "            # Writing the list of black moves for each game to their respective game files\n",
    "            with open(f\"{game_number}b.txt\", 'w') as black_moves:\n",
    "                black_moves.write(' '.join(black))\n",
    "\n",
    "        # To report the number of files which have been created, we can use the listdir method from the os module\n",
    "        # Using the os module, we can extract the path of the current working directory with the .getcwd method\n",
    "        white_file = [file for file in os.listdir(os.getcwd()) if file.endswith(\"w.txt\")]\n",
    "        black_file = [file for file in os.listdir(os.getcwd()) if file.endswith(\"b.txt\")]\n",
    "\n",
    "        # Printing the number of files created for white moves and black moves per game\n",
    "        print(f\"White moves files: {len(white_file)}\")\n",
    "        print(f\"Black moves files: {len(black_file)}\")\n",
    "\n",
    "        # Printing the total number of files created including the black and white moves files\n",
    "        print(f\"Total number of files created: {len(white_file) + len(black_file)}\")\n",
    "\n",
    "        # Confirmation of successful files creation\n",
    "        print(\"Success!\\n\")\n",
    "\n",
    "    # ################### 3.4: Dataframe Counts ################### #\n",
    "\n",
    "    # Defining a method to generate different moves files for white moves and black moves\n",
    "    def first_move(self):\n",
    "\n",
    "        # Reading from the game_string.txt file\n",
    "        lines = self.chess_games.readlines()\n",
    "\n",
    "        # Defining a regex pattern to remove trailing numbers for each move pair. For eg. 1.e4 d3 to e4 d3\n",
    "        pattern4 = re.compile(r\"\\d{1,3}\\.\")\n",
    "\n",
    "        # Defining a for loop to access each line of the file\n",
    "        for line in range(0, len(lines)):\n",
    "            # Capture the above defined regex pattern and remove it from every line in the file\n",
    "            lines[line] = re.sub(pattern4, \"\", lines[line])\n",
    "            lines[line] = lines[line].split()\n",
    "\n",
    "        # Pulling the white first moves and black first moves of every game into their individual lists\n",
    "        white_first_moves = [game[0] for game in lines]\n",
    "\n",
    "        # A game may have only one move so this will only record the black first moves only if\n",
    "        # they exist in the game\n",
    "        black_first_moves = [game[1] for game in lines if len(game) > 1]\n",
    "\n",
    "        # Putting all the first white moves and first black moves into a NumPy array\n",
    "        white_first_moves_np = np.array(white_first_moves)\n",
    "        black_first_moves_np = np.array(black_first_moves)\n",
    "\n",
    "        # Collecting all the unique moves for white and black moves and the number of occurrences\n",
    "        # for each of them using the unique() method of NumPy and the count flag set to True.\n",
    "        white_first_moves_np_unq, white_counts = np.unique(white_first_moves_np, return_counts=True)\n",
    "        black_first_moves_np_unq, black_counts = np.unique(black_first_moves_np, return_counts=True)\n",
    "\n",
    "        # Creating two nested arrays. Each inner array contains all the first moves and the number of\n",
    "        # times it has occurred throughout all the games\n",
    "        white_frequency = np.asarray((white_first_moves_np_unq, white_counts)).T\n",
    "        black_frequency = np.asarray((black_first_moves_np_unq, black_counts)).T\n",
    "\n",
    "        # Using Pandas to create two dataframes with two columns each. The first column contains\n",
    "        # the move itself. The second column contains its number of occurrences in string format.\n",
    "        white_first_moves_df = pd.DataFrame(white_frequency, columns=['Move',\n",
    "                                                                      'Number_of_Occurrences'])\n",
    "\n",
    "        black_first_moves_df = pd.DataFrame(black_frequency, columns=['Move',\n",
    "                                                                      'Number_of_Occurrences'])\n",
    "\n",
    "        # To sort both dataframes in descending order, the data type of the 'Number_of_Occurrences'\n",
    "        # must be changed from string to integer\n",
    "        white_first_moves_df[\"Number_of_Occurrences\"] = white_first_moves_df[\"Number_of_Occurrences\"] \\\n",
    "            .astype(str).astype(int)\n",
    "\n",
    "        black_first_moves_df[\"Number_of_Occurrences\"] = black_first_moves_df[\"Number_of_Occurrences\"] \\\n",
    "            .astype(str).astype(int)\n",
    "\n",
    "        # Sorting the two dataframes in descending order with the most commonly used move at the top\n",
    "        white_first_moves_df.sort_values('Number_of_Occurrences', inplace=True,\n",
    "                                         ascending=False)\n",
    "\n",
    "        black_first_moves_df.sort_values('Number_of_Occurrences', inplace=True,\n",
    "                                         ascending=False)\n",
    "\n",
    "        # When a dataframe is sorted on the basis of one of its columns, its indexes are jumbled.\n",
    "        # This will reset the index after the sorting process is done.\n",
    "        white_first_moves_df = white_first_moves_df.reset_index(drop=True)\n",
    "        black_first_moves_df = black_first_moves_df.reset_index(drop=True)\n",
    "\n",
    "        '''\n",
    "        These two commented display() methods can be used to check each data frame for the \n",
    "        first white moves and first black moves respectively.\n",
    "        Please note: display() is a Pandas styler which generates HTML. Pycharm will not be able to\n",
    "        parse this. This can only be used in Jupyter notebook which uses a browser\n",
    "        # display(white_first_moves_df)\n",
    "        # display(black_first_moves_df)\n",
    "        '''\n",
    "        # Putting the two data frames into a tuple and returning it when this function is called\n",
    "        tup_first_moves_df = (white_first_moves_df, black_first_moves_df)\n",
    "\n",
    "        return tup_first_moves_df\n",
    "\n",
    "    # ################### 3.5: Plotting ################### #\n",
    "\n",
    "    # Defining a method to plot the most common first moves\n",
    "    def chess_moves_plot(self):\n",
    "\n",
    "        # Calling the first_move function with an instance of the\n",
    "        # class object and putting the value returned by the method into a variable\n",
    "        first_moves_tuple = self.first_move()\n",
    "\n",
    "        # Extracting the two dataframes for white moves and black moves respectively\n",
    "        # from the above tuple\n",
    "        white_moves_df = first_moves_tuple[0]\n",
    "        white_moves_df[\"Type\"] = \"White\"  # Adding a label column called type to identify a move as a white move\n",
    "\n",
    "        black_moves_df = first_moves_tuple[1]\n",
    "        black_moves_df[\"Type\"] = \"Black\"  # Adding a label column called type to identify a move as a black move\n",
    "\n",
    "        # Combining the above two data frames into a single data frame\n",
    "        moves_combined_df = pd.concat([white_moves_df, black_moves_df], ignore_index=True)\n",
    "\n",
    "        # Sorting the two dataframes in descending order, based on the number of occurrences of each move\n",
    "        moves_combined_df.sort_values('Number_of_Occurrences', inplace=True,\n",
    "                                      ascending=False)\n",
    "\n",
    "        # Resetting the index of the dataframe as the previous sorting operation will jumble\n",
    "        # the indexes\n",
    "        moves_combined_df = moves_combined_df.reset_index(drop=True)\n",
    "\n",
    "        '''\n",
    "        The display() method can be used to check the above combined data frame.\n",
    "        Please note: display() is a Pandas styler which generates HTML. Pycharm will not be able to\n",
    "        parse this. This can only be used in Jupyter notebook which uses a browser\n",
    "        # display(moves_combined_df)\n",
    "        '''\n",
    "        # Select the top 10 moves\n",
    "        most_common_10_df = moves_combined_df.head(10)\n",
    "\n",
    "        print(most_common_10_df)\n",
    "        # display(most_common_10_df) # Please note the above comment block before using this command\n",
    "\n",
    "        # Defining a dictionary containing a colour palette for better visualisation of\n",
    "        # white moves and black moves respectively. The number of colours must be equal to\n",
    "        # the number of label types. In our combined dataframe, we have two types of labels:\n",
    "        # White and Black. Using the colour 'silver' to identify a white move and 'black' to\n",
    "        # identify a black move.\n",
    "        colors = {'White': 'silver', 'Black': 'black'}\n",
    "\n",
    "        # Applying each color to the two labels in the dataframe\n",
    "        color = most_common_10_df['Type'].apply(lambda c: colors[c])\n",
    "\n",
    "        # Plotting a bar plot for top ten most common moves and assigning the colors to each label\n",
    "        # First column will be plotted on the X-axis and the second column will be plotted on the Y-axis\n",
    "        plt.bar(most_common_10_df[\"Move\"], most_common_10_df[\"Number_of_Occurrences\"],\n",
    "                color=color, label=colors)\n",
    "\n",
    "        # Assigning labels to the X-axis, Y-axis values and provide a title for the plot\n",
    "        plt.xlabel('Move')\n",
    "        plt.ylabel('Frequency')\n",
    "        plt.title('Most Common First Moves in Chess')\n",
    "\n",
    "        # Extracting the keys of the colors dictionary into a list. This list contains the two labels\n",
    "        # for the plot legend: White and Black\n",
    "        labels = list(colors.keys())\n",
    "\n",
    "        # Specifying the handles for the legend. A handle is defined as the original object which\n",
    "        # is used to generate an approximate entry in the legend.\n",
    "        # Source: https://matplotlib.org/stable/tutorials/intermediate/legend_guide.html\n",
    "        handles = [plt.Rectangle((0, 0), 1, 1, color=colors[label]) for label in labels]\n",
    "        plt.legend(handles, labels)\n",
    "\n",
    "        # Generate the plot once all the details have been provided in terms of styling and displaying it\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "# Asking the user to input the name of the chess file to be parsed\n",
    "chess_file_input = input('Enter the name of the file to be parsed along with its \\\n",
    "extension( Example: chess_game.pgn): ')\n",
    "\n",
    "# Checking whether the filename inputted by the user has a valid .pgn extension and prompting the user\n",
    "# if an invalid filename is inputted by the user\n",
    "while True:\n",
    "    if not chess_file_input.lower()[-4:] == \".pgn\":\n",
    "        chess_file_input = input('Please input a valid filename with a .pgn \\\n",
    "extension( Example: chess_game.pgn)')\n",
    "    else:\n",
    "        break\n",
    "\n",
    "# Exception handling to check if the file is present in the current directory\n",
    "try:\n",
    "    # Reading from the file inputted by the user\n",
    "    chess_file = open(chess_file_input, 'r')\n",
    "except IOError:\n",
    "    print(f\"Error! The file does not exist. Please check your directory\")\n",
    "else:\n",
    "    # Define an object of the class ChessGame\n",
    "    chess1 = ChessGame(chess_file)\n",
    "\n",
    "    # Call the method regex_filter using the object of class ChessGame\n",
    "    chess1.regex_filter()\n",
    "\n",
    "    # Close the chess game file\n",
    "    chess_file.close()\n",
    "\n",
    "    # Opening the game_strings file. This file was created by calling a method of class ChessGame\n",
    "    # With an instance of the object of class ChessGame\n",
    "    game_strings = open(\"game_string.txt\", 'r')\n",
    "\n",
    "    # Defining a new instance of the object of class ChessGame\n",
    "    chess2 = ChessGame(game_strings)\n",
    "\n",
    "    # Calling the moves_generator() method with the above instance\n",
    "    chess2.moves_generator()\n",
    "\n",
    "    # Closing the file to release the read lock on the file\n",
    "    game_strings.close()\n",
    "\n",
    "    # Creating a new variable to store the game_string.txt file\n",
    "    game_strings1 = open(\"game_string.txt\", 'r')\n",
    "\n",
    "    # Defining a third instance of the object of class ChessGame\n",
    "    chess3 = ChessGame(game_strings1)\n",
    "\n",
    "    # Calling the plotting function to display the bar plot\n",
    "    chess3.chess_moves_plot()\n",
    "\n",
    "    # Closing the file\n",
    "    game_strings1.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2a221f9",
   "metadata": {},
   "source": [
    "## 3. Understanding the Plot\n",
    "\n",
    "These points can help make sense of the graph produced by the code:\n",
    "\n",
    "1. Given the scope of the data to be generated, a bar plot is one of the simplest options with which this data can be represented. The data consist of the top 10 most common moves (black or white) with their total number of occurrences across all the games in the chess_game.pgn file.\n",
    "\n",
    "2. This number of most common occurrences may be less than or equal to 10 depending on different `.pgn` files. For example, there may be a `.pgn` file which contains games with 0 to 9 unique chess moves (black or white) occurring as the most common chess moves. In that case, the graph may display less than ten different chess moves. However, considering that we only require the top 10 most common moves, I have restricted the dataframe of moves accordingly. Additionally, I have also written the title of the plot as \"Most Common First Moves in Chess\" instead of \"Top Ten Most Common First Moves in Chess\" as the most common moves can be less than 10 depending on the variability of the games in the .pgn file being parsed. However, since I have restricted the dataframe to 10 rows only, the number of top most common first moves cannot be more than 10.\n",
    "\n",
    "3. From the graph produced for the `chess_games.pgn` file, we can see that overall, the number of occurrences for black first moves are more than the number of occurrences for the white first moves. An initial observation can be made that the black moves which are on this graph the possible moves for each of the white first moves on the same graph. In other words, in a chess match, White starts the game. Therefore, the person who starts the game has a momentary advantage to restrict his opponent to a limited number of black first moves. For example, for the games in the chess_game.pgn file, we can make a rough guesstimate that for the 4 most common white first moves, there are 6 possible  black first moves which can be made.\n",
    "\n",
    "4. Beyond the scope of this project, a possible next step to derive more insights would be to identify which is the most common black first move for each unique white first move. Additionally, we can determine if there is a correlation between the most common first moves for white or black pieces and the final game score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c15f7751",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}