classesDev.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting package/synthSportPlayer/sportplayer.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile package/synthSportPlayer/sportplayer.py\n",
    "from numpy.random import normal, randint, rand\n",
    "from numpy import log2\n",
    "from math import ceil\n",
    "import pandas as pd\n",
    "from random import shuffle\n",
    "import names\n",
    "import pickle\n",
    "import os\n",
    "\n",
    "class player:\n",
    "    \"\"\"\n",
    "    A class to model any sports player/team.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    skill : int or float\n",
    "            The underlying 'true' skill of a player\n",
    "    variance : int or float\n",
    "               How much the player varies in their performance. The lower this is the more consistent they are in their performance\n",
    "    name : str\n",
    "           The players name/id that will be used as a reference later on\n",
    "    pointLimit : int, default 10\n",
    "                 The max number of points a player is allowed to keep in the :py:attr:`pointRec`.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    pointRec : list of int\n",
    "               A record of the points the this player has earnt from a tournament in the order that they earnt them.\n",
    "    totalPoints : int\n",
    "                  The total of all the points in :py:attr:`pointRec`.\n",
    "    \"\"\"\n",
    "    def __init__(self,skill,variance,name,pointLimit=10):\n",
    "        \"\"\"\n",
    "        The init method of the class.\n",
    "        \"\"\"\n",
    "        if not((type(skill)==int)|(type(skill)==float)):\n",
    "            raise TypeError('Skill must be an int or a float')\n",
    "        if not((type(variance)==int)|(type(variance)==float)):\n",
    "            raise TypeError('variance must be an int or a float')\n",
    "        if type(name)!=str:\n",
    "            raise TypeError('name must be a str')\n",
    "        if type(pointLimit)!=int:\n",
    "            raise TypeError('pointLimit must be an int')\n",
    "        \n",
    "        self.skill = skill\n",
    "        self.variance = variance\n",
    "        self.name = name\n",
    "        self.pointRec=[]\n",
    "        self.totalPoints=0\n",
    "        self.pointLimit=pointLimit\n",
    "        \n",
    "    def perform(self):\n",
    "        \"\"\"\n",
    "        A method getting the player to perform.\n",
    "        \n",
    "        A numerical value is returned representing the players performance 'on the day'. \n",
    "        This is generate from a normal dist. with mean equal to the players skill and var equal to the player variance, \n",
    "        which is then rounded to the nearest integer.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        performance : int\n",
    "                      The value representing the player performance on the day, which is greater than or equal to 0.\n",
    "        \"\"\"\n",
    "        return max(round(normal(self.skill,self.variance)),0)\n",
    "    \n",
    "    def selfsummary(self):\n",
    "        \"\"\"\n",
    "        A method to print out the characteristics of the player.\n",
    "        \"\"\"\n",
    "        outstr = \"Name: {}\\nSkill: {}\\nVar: {}\\nPoint Record: {}\\nTotal points: {}\\nPoint limit: {}\"\n",
    "        print(outstr.format(self.name,self.skill,self.variance,self.pointRec,self.totalPoints,self.pointLimit))\n",
    "        \n",
    "    def gainPoints(self,points):\n",
    "        \"\"\"\n",
    "        A method to update the current points of the player.\n",
    "        \n",
    "        The points provided are added to the players :py:attr:`pointRec`. If the number of entries in the :py:attr:`pointRec` is greater than pointLimit, \n",
    "        then the oldest entry is removed. After this the :py:attr:`totalPoints` arrtibute is updated with the new total of :py:attr:`pointRec`.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        points : int\n",
    "                 Points to be added to the players :py:attr:`pointRec`.\n",
    "        \"\"\"\n",
    "        if type(points)!=int:\n",
    "            raise TypeError('points must be an int')\n",
    "            \n",
    "        self.pointRec.append(points)\n",
    "        if len(self.pointRec)>self.pointLimit:\n",
    "            self.pointRec.pop(0)\n",
    "        self.totalPoints = sum(self.pointRec)\n",
    "    \n",
    "class match:\n",
    "    \"\"\"\n",
    "    A class to handle the match between two :py:class:`player`'s or any :py:class:`bye`.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    player1 : player or bye\n",
    "              The first :py:class:`player` or :py:class:`bye` that is participating in the match.\n",
    "    player2 : player or bye\n",
    "              The second :py:class:`player` or :py:class:`bye` that is participating in the match.\n",
    "    \"\"\"\n",
    "    def __init__(self,player1,player2):\n",
    "        \"\"\"\n",
    "        The init function of the class.\n",
    "        \"\"\"\n",
    "        if not((type(player1)==player)|(type(player1)==bye)):\n",
    "            raise TypeError('player1 must be a player or a bye')\n",
    "        if not((type(player2)==player)|(type(player2)==bye)):\n",
    "            raise TypeError('player2 must be a player or a bye')\n",
    "            \n",
    "        self.player1 = player1\n",
    "        self.player2 = player2\n",
    "    \n",
    "    def playMatch(self):\n",
    "        \"\"\"\n",
    "        A method to excute the match between the two player's given to the match.\n",
    "        \n",
    "        Both the perform methods of the players are activated and the :py:class:`player` with the higher performance score is the winner. \n",
    "        If the two values are equal, then a winner is randomly chosen. If the match is a player vs a bye then the player automatically wins\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        winner : player or bye\n",
    "                 The :py:class:`player` who won the match. A :py:class:`bye` is only returned if the match is between 2 byes.\n",
    "        loser : player or bye\n",
    "                The :py:class:`player` who lost the match\n",
    "        matchReport : list\n",
    "                      A list containing the information from the match it has just played out. \n",
    "                      Containing for both players: their name, their total points, their performance value for that match. \n",
    "                      Then finally the name of the player who won.\n",
    "        \"\"\"\n",
    "        p1 = self.player1.perform()\n",
    "        p2 = self.player2.perform()\n",
    "        if p1==p2:\n",
    "            t=(rand()-0.5)\n",
    "        else:\n",
    "            t=0\n",
    "        if (p1+t)>p2:\n",
    "            return self.player1,self.player2,[self.player1.name,self.player1.totalPoints,p1,self.player2.name,self.player2.totalPoints,p2,self.player1.name]\n",
    "        else:\n",
    "            return self.player2,self.player1,[self.player1.name,self.player1.totalPoints,p1,self.player2.name,self.player2.totalPoints,p2,self.player2.name]\n",
    "        \n",
    "class tournament:\n",
    "    \"\"\"\n",
    "    A class to model a tournament\n",
    "    \n",
    "    The tournament is the classic 1v1 elimination tournament where the winner of a match proceeds through to the next round.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    playerList : list of :py:class:`player`\n",
    "                 A list containg the players who are competing in this tournament. If this is not a power of 2 then byes will be added \n",
    "                 to make up the numbers then then the list of players shuffled.\n",
    "    pointPerRound : int, default 5\n",
    "                    The number of points that a player earns at each stage that they get to.\n",
    "                    \n",
    "    Attributes\n",
    "    ----------\n",
    "    matchRec :  list of list\n",
    "                A list where the match results are stored when they are completed.\n",
    "    round : int\n",
    "            An integer used to track what current round the tournament is in.\n",
    "    tournRes : DataFrame\n",
    "               A pandas dataframe that is created and assigned once the tournament is complete containing all the match results, made from the :py:attr:`matchRec` attribute.\n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self, playerList,pointPerRound=5):\n",
    "        \"\"\"\n",
    "        The init function of this class.\n",
    "        \"\"\"\n",
    "        if not(all(type(n)==player for n in playerList)):\n",
    "            raise TypeError(\"playerList is not a list of only players\")\n",
    "        if type(pointPerRound)!=int:\n",
    "            raise TypeError('pointPerRound must be an int')\n",
    "            \n",
    "        self.currentRound = playerList\n",
    "        if not(log2(len(self.currentRound)).is_integer()):\n",
    "            self.currentRound+=[bye() for i in range(0,(2**ceil(log2(len(self.currentRound)))-len(self.currentRound)))]\n",
    "            shuffle(self.currentRound)\n",
    "        \n",
    "        self.points=pointPerRound\n",
    "        self.matchRec=[]\n",
    "        self.round=1\n",
    "        self.tournRes=None\n",
    "    \n",
    "    def playTourn(self):\n",
    "        \"\"\"\n",
    "        A method to play the entire tournament.\n",
    "        \n",
    "        Activating this method will play out the tournament until there is one :py:class:`player` remaining as the winner. \n",
    "        At which point the final tournament results are created and stored in :py:attr:`tournRes`.\n",
    "        \"\"\"\n",
    "        while len(self.currentRound)>1:\n",
    "            nextRound = self.playRound()\n",
    "            self.currentRound = nextRound\n",
    "            self.round+=1\n",
    "        self.currentRound[0].gainPoints(self.round*self.points)\n",
    "        self.tournRes = pd.DataFrame(self.matchRec,columns=[\"Round\", \"Match\",\"player1_id\",\"player1_rnkPoints\",\"player1_perform\",\"player2_id\",\"player2_rnkPoints\",\"player2_perform\",\"winner_id\"])\n",
    "        \n",
    "        \n",
    "    def playRound(self):\n",
    "        \"\"\"\n",
    "        A method to play all the matches in the current round.\n",
    "        \n",
    "        This plays out the round with the players that have made it through to the current stage. Each match result is added to the :py:attr:`matchRec`, \n",
    "        and the loser gains points equal to the round where they got to.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        nextRound : list of players\n",
    "                    A list of players who won their matches and proceed through to the next round\n",
    "        \"\"\"\n",
    "        nextRound=[]\n",
    "        for i in range(0,len(self.currentRound)//2):\n",
    "            currentMatch=match(self.currentRound[2*i],self.currentRound[(2*i)+1])\n",
    "            winner,loser,res = currentMatch.playMatch()\n",
    "            loser.gainPoints(self.round*self.points)\n",
    "            nextRound.append(winner)\n",
    "            self.matchRec.append([self.round,i+1]+res)\n",
    "        return nextRound\n",
    "    \n",
    "    def reset(self):\n",
    "        \"\"\"\n",
    "        A method to reset the tournament to be able to be played again.\n",
    "        \"\"\"\n",
    "        self.matchRec=[]\n",
    "        self.round=1\n",
    "        self.tournRes=None\n",
    "\n",
    "def generateNames(num):\n",
    "    genNames=[]\n",
    "    while len(genNames)<num:\n",
    "        x= names.get_full_name()\n",
    "        if not(x in genNames):\n",
    "            genNames.append(x)\n",
    "    return genNames  \n",
    "        \n",
    "def generatePlayers(number,maxSkill=100,var=10):\n",
    "    \"\"\"\n",
    "    A function to generate a numbers of players.\n",
    "    \n",
    "    This will generate the given number of players whose skill is uniformly random between 1 and maxSkill, and whose variance is equal to var.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    number : int\n",
    "             The number of players that are to be created.\n",
    "    maxSkill : int or float, default 100\n",
    "               The max skill that a player can have.\n",
    "    var : int or float, default 10\n",
    "          The variance to give to each player.\n",
    "             \n",
    "    Returns\n",
    "    -------\n",
    "    playerList : list of players\n",
    "                 A list containing the players created.\n",
    "    playerInfo : DataFrame\n",
    "                 A table with information about the players created.\n",
    "    \"\"\"\n",
    "    if type(number)!=int:\n",
    "        raise TypeError('number must be an int')\n",
    "    if not((type(maxSkill)==int)|(type(maxSkill)==float)):\n",
    "        raise TypeError('maxSkill must be an int or a float')\n",
    "    if not((type(var)==int)|(type(var)==float)):\n",
    "        raise TypeError('var must be an int or a float')\n",
    "    \n",
    "    playerList = []\n",
    "    playerinfo = []\n",
    "    genNames=generateNames(number)\n",
    "    for i in range(0,number):\n",
    "        skill = randint(1,maxSkill)\n",
    "        playerList.append(player(skill,var, genNames[i]))\n",
    "        playerinfo.append([genNames[i],skill,var,0])\n",
    "    playerinfo = pd.DataFrame(playerinfo,columns=[\"name\",\"skill\",\"variance\",\"week_-1\"])\n",
    "    playerinfo.sort_values(\"skill\",ascending=False,inplace=True)\n",
    "    return playerList, playerinfo\n",
    "\n",
    "\n",
    "def fetchPlayerSummary(playerList):\n",
    "    \"\"\"\n",
    "    A function to generate a player summary table.\n",
    "    \n",
    "    Given a list of players this will generate a pandas table with the players summary.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    playerList : list of player\n",
    "                 A list of players whose summary wants to be fetched\n",
    "                 \n",
    "    Returns\n",
    "    -------\n",
    "    playerinfo : DataFrame\n",
    "                 A data frame containg the summary information of all the players provided.\n",
    "    \"\"\"\n",
    "    playerinfo = []\n",
    "    for player in playerList:\n",
    "        playerinfo.append([player.name,player.skill,player.variance,player.totalPoints])\n",
    "    playerinfo = pd.DataFrame(playerinfo,columns=[\"name\",\"skill\",\"variance\",\"week_-1\"])\n",
    "    playerinfo.sort_values(\"skill\",ascending=False,inplace=True)\n",
    "    return playerinfo\n",
    "\n",
    "class season:\n",
    "    \"\"\"\n",
    "    A class to handle a season of tournaments being played.\n",
    "    \n",
    "    A season is a squence of tournaments that are played by a group of players one after another and collect points as they go based \n",
    "    on performance in each tournament.\n",
    "    \n",
    "    Notes\n",
    "    -----\n",
    "    At this points the seasons automatically use :py:class:`tournament` and does not work with :py:class:`robin`\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    numPlayers : int, default 16\n",
    "                 The number of players that will be generated to play in this season. This will be overridden if players are provided\n",
    "    tournToPlay : int, default 20\n",
    "                  The number of tournaments that this season will have,\n",
    "    players : list of players, default None\n",
    "              Optional. If there are pre-existing players that the user wishes to enter into this season. The number of players in the list will override numPlayers. \n",
    "    playerSum : DataFrame, default None\n",
    "                Optional. If the player are being provided externally then their summary data table can be provided for their total point record to be appended to.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    week : int\n",
    "           An integer to keep track of what week (tournament) is being played out.\n",
    "    tournRecs : list of DataFrames\n",
    "                A list that stores the results from each tournament.\n",
    "    seasonRes : Dataframe, default None\n",
    "                A pandas dataframe with all of the tournament results concatenated into one dataframe, which is done upon season completion.\n",
    "    \"\"\"\n",
    "    def __init__(self,numPlayers=16,tournToPlay=20, players=None, playerSum=None):\n",
    "        \"\"\"\n",
    "        The init method of this class.\n",
    "        \"\"\"\n",
    "        if type(numPlayers)!=int:\n",
    "            raise TypeError('numPlayers must be an int')\n",
    "        if type(tournToPlay)!= int:\n",
    "            raise TypeError('tournToPlay must be an int')\n",
    "        if players!=None:\n",
    "            if not(all(type(n)==player for n in players)):\n",
    "                raise TypeError(\"playerList is not a list of only players\")\n",
    "        if playerSum!=None:\n",
    "            if not(type(playerSum)==pd.core.frame.DataFrame):\n",
    "                raise TypeError(\"playerSum must be a pandas dataframe\")\n",
    "        \n",
    "        self.tournsToPlay = tournToPlay\n",
    "        self.week=0\n",
    "        self.tournRecs=[]\n",
    "        self.seasonRes=None\n",
    "        if players == None:\n",
    "            self.numPlayers = numPlayers\n",
    "            self.players, self.playerSum = generatePlayers(self.numPlayers)\n",
    "        else:\n",
    "            self.numPlayers = len(players)\n",
    "            self.players = players\n",
    "            \n",
    "            if playerSum==None:\n",
    "                self.playerSum = fetchPlayerSummary(players)\n",
    "            else:\n",
    "                self.playerSum = playerSum\n",
    "    \n",
    "    def playSeason(self):\n",
    "        \"\"\"\n",
    "        A method to play out the season of tournaments.\n",
    "        \n",
    "        This method will play all of the tournaments in order, storing tournament results, recording players total points and shuffling the order of players\n",
    "        inbetween each tournament.\n",
    "        \"\"\"\n",
    "        if self.week == self.tournsToPlay:\n",
    "            print(\"This season has already been played. Please reset, use: .rest()\")\n",
    "        while self.week<self.tournsToPlay:\n",
    "            shuffle(self.players)\n",
    "            tourn = tournament(self.players)\n",
    "            tourn.playTourn()\n",
    "            self.gatherPoints()\n",
    "            tourn.tournRes[\"Tourn\"] = self.week\n",
    "            self.tournRecs.append(tourn.tournRes)\n",
    "            self.week+=1\n",
    "            self.players = [x for x in self.players if type(x)==player]\n",
    "        self.seasonRes = pd.concat(self.tournRecs)\n",
    "    \n",
    "    def reset(self):\n",
    "        \"\"\"\n",
    "        A method to reset the season. \n",
    "        \n",
    "        It won't reset the players but resets the week count and the tournament results record. \n",
    "        \"\"\"\n",
    "        self.week=0\n",
    "        self.tournRecs=[]\n",
    "        \n",
    "    def gatherPoints(self):\n",
    "        \"\"\"\n",
    "        A method to gather the total points of players aftern a tournament has been completed. These are store it in the playerSum.\n",
    "        \"\"\"\n",
    "        pointlist=[]\n",
    "        for player in self.players:\n",
    "            pointlist.append([player.name,player.totalPoints])\n",
    "        pointlist=pd.DataFrame(pointlist,columns = ['name','week_'+str(self.week)] )\n",
    "        self.playerSum = self.playerSum.merge(pointlist, on= 'name')\n",
    "    \n",
    "    def export(self,fldr='seasonData'):\n",
    "        \"\"\"\n",
    "        A function to export the players, the tournament results tables, and the season points table as CSVs.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        fldr : str, default 'seasonData'\n",
    "               The name to call the folder the results shall be stored in.\n",
    "        \"\"\"\n",
    "        if type(fldr)!=str:\n",
    "            raise TypeError(\"fldr must be a str\")\n",
    "        if fldr in [x for x in os.listdir() if os.path.isdir(x)]:\n",
    "            pass\n",
    "        else:\n",
    "            os.mkdir(fldr)\n",
    "        file_to_store = open(fldr+\"/players.pickle\", \"wb\")\n",
    "        pickle.dump(self.players, file_to_store)\n",
    "        file_to_store.close()\n",
    "        \n",
    "        for i in range(0,len(self.tournRecs)):\n",
    "            self.tournRecs[i].to_csv(fldr+\"/tournament_\"+str(i)+\".csv\",index=False)\n",
    "        \n",
    "        self.playerSum.to_csv(fldr+\"/seasonPoints.csv\",index=False)\n",
    "        \n",
    "    \n",
    "class liveTourn(tournament):\n",
    "    \"\"\"\n",
    "    A class to facilitate live dashboarding of a season/tournament being played\n",
    "    \n",
    "    For further info see the parent class tournament.\n",
    "    \"\"\"\n",
    "    def __init__(self, playerList,pointPerRound=5):\n",
    "        super().__init__(playerList,pointPerRound)\n",
    "    \n",
    "    def playTourn(self):\n",
    "        \"\"\"\n",
    "        A method to play the tournament. \n",
    "        \n",
    "        Unlike it's parent class, when this method is called it will only play the next round of the tournament.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        complete : bool\n",
    "                   A boolean to indicate if the tournament is now complete.\n",
    "        \"\"\"\n",
    "        if len(self.currentRound)>1:\n",
    "            nextRound = self.playRound()\n",
    "            self.currentRound = nextRound\n",
    "            self.round+=1\n",
    "            if len(self.currentRound)==1:\n",
    "                self.currentRound[0].gainPoints(self.round*self.points)\n",
    "                self.tournRes = pd.DataFrame(self.matchRec,columns=[\"Round\", \"Match\",\n",
    "                                                                    \"player1_id\",\"player1_rnkPoints\",\"player1_perform\",\n",
    "                                                                    \"player2_id\",\"player2_rnkPoints\",\"player2_perform\",\"winner_id\"])\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "        else:\n",
    "            return True\n",
    "        \n",
    "class liveSeason(season):\n",
    "    \"\"\"\n",
    "    A class to facilitate live dashboarding of a season/tournament being played\n",
    "    \n",
    "    For further info see the parent class season.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    currentTourn : liveTourn\n",
    "                   The current tournament that is in progress\n",
    "    currentTournComplete : bool\n",
    "                           A boolean indicating if the current tournament is completed or not.\n",
    "    \"\"\"\n",
    "    def __init__(self,numPlayers=16,tournToPlay=20, players=None, playerSum=None):\n",
    "        super().__init__(numPlayers=16,tournToPlay=20, players=None, playerSum=None)\n",
    "        shuffle(self.players)\n",
    "        self.currentTourn = liveTourn(self.players)\n",
    "        self.currentTournComplete = False\n",
    "        \n",
    "    def playSeason(self):\n",
    "        \"\"\"\n",
    "        A method to play the season.\n",
    "        \n",
    "        Unlike it's parent class, when this method is called it will only play the next round of the tournament. But if the tournament is complete \n",
    "        it will update the records and move onto make the next tournament and play the first round.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        complete : bool\n",
    "                   A boolean indicating if the season is completed or not.\n",
    "        \"\"\"\n",
    "        if self.week == self.tournsToPlay:\n",
    "            self.seasonRes = pd.concat(self.tournRecs)\n",
    "            return True\n",
    "        else:\n",
    "            if self.currentTournComplete:\n",
    "                shuffle(self.players)\n",
    "                self.currentTourn = liveTourn(self.players)\n",
    "\n",
    "            self.currentTournComplete = self.currentTourn.playTourn()\n",
    "            if self.currentTournComplete:\n",
    "                self.gatherPoints()\n",
    "                self.currentTourn.tournRes[\"Tourn\"] = self.week\n",
    "                self.tournRecs.append(self.currentTourn.tournRes)\n",
    "                self.week+=1\n",
    "                self.players = [x for x in self.players if type(x)==player]\n",
    "            return False\n",
    "            \n",
    "class robin:\n",
    "    \"\"\"\n",
    "    A class to model a round robin tournament.\n",
    "    \n",
    "    A round robin is a variation on a tournament setting where all the players play against each other. \n",
    "    The winner is normally the one with the most matches. If there's any a draw it then goes to their win difference. \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    playerList : list of player\n",
    "                 The players who are to play in this this round robin. If there is an odd number of players, a :py:class:`bye` will be added in.\n",
    "    pointPerWin : int, default 5\n",
    "                  The number of points that players will recieve at the end of the tournament for each win.\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    numPlayers : int\n",
    "                 The number of players that are competing in this round robin.\n",
    "    matchRec :  list of list\n",
    "                A list where the match results are stored when they are completed.\n",
    "    round : int\n",
    "            An integer used to track what current round the tournament is in.\n",
    "    tournRec : DataFrame\n",
    "               A pandas dataframe that is created and assigned once the tournament is complete containing all the match results, made from the :py:attr:`matchRec` attribute.\n",
    "    winLossRec : DataFrame\n",
    "                 A pandas dataframe containing the number of wins, losses and the winning point difference for each player\n",
    "    \"\"\"\n",
    "    def __init__(self,playerList,pointPerWin=5):\n",
    "        \"\"\"\n",
    "        The init function of the class.\n",
    "        \"\"\"\n",
    "        if not(all(type(n)==player for n in playerList)):\n",
    "            raise TypeError(\"playerList is not a list of only players\")\n",
    "        if type(pointPerWin)!=int:\n",
    "            raise TypeError('pointPerWin must be an int')\n",
    "        \n",
    "        self.playerList = playerList\n",
    "        self.pointPerWin = pointPerWin\n",
    "        self.numPlayers = len(self.playerList)\n",
    "        if (self.numPlayers%2)!=0:\n",
    "            self.playerList.append(bye())\n",
    "            self.numPlayers+=1\n",
    "        self.matchRec=[]\n",
    "        self.tournRes=None\n",
    "        self.round=1\n",
    "        \n",
    "        names=[]\n",
    "        for py in self.playerList:\n",
    "            names.append([py.name,0,0,0])\n",
    "        self.winLossRec = pd.DataFrame(names,columns=[\"Player\",\"Wins\",\"Losses\",\"Diff\"])\n",
    "        self.winLossRec.set_index(\"Player\",inplace=True)\n",
    "        \n",
    "    def permute(self):\n",
    "        \"\"\"\n",
    "        Permute the order of the players for the next round of the round robin.\n",
    "        \n",
    "        For a round robin you have to permute the players in a certain way to make everyone play everyone else.\n",
    "        \"\"\"\n",
    "        self.playerList = [self.playerList[0]]+self.playerList[2:]+[self.playerList[1]]\n",
    "        \n",
    "    def playRound(self):\n",
    "        \"\"\"\n",
    "        A method to play all the matches in the current round.\n",
    "        \n",
    "        This plays out the round with the players against their allocated opponent for the current round. \n",
    "        Each match result is added to the :py:attr:`matchRec`, and the :py:attr:`winLossRec` is updated with the results, \n",
    "        unless it is against a :py:class:`bye`\n",
    "        \"\"\"\n",
    "        matchNum = 1 \n",
    "        for i in range(0,self.numPlayers//2):\n",
    "            p1=self.playerList[i]\n",
    "            p2=self.playerList[(self.numPlayers)-i-1]\n",
    "            currentMatch=match(p1,p2)\n",
    "            winner,loser,res = currentMatch.playMatch()\n",
    "            if type(loser)!=bye:\n",
    "                self.winLossRec.loc[winner.name,\"Wins\"]+=1\n",
    "                self.winLossRec.loc[winner.name,\"Diff\"]+=abs(res[2]-res[5])\n",
    "                self.winLossRec.loc[loser.name,\"Losses\"]+=1\n",
    "            \n",
    "            self.matchRec.append([self.round,matchNum]+res)\n",
    "            matchNum+=1\n",
    "        self.round+=1\n",
    "    \n",
    "    def playTourn(self):\n",
    "        \"\"\"\n",
    "        A method to play the entire tournament.\n",
    "        \n",
    "        Activating this method will play out the tournament until every :py:class:`player` has played everyother :py:class:`player`. \n",
    "        At which point the final tournament results are created and stored in :py:attr:`tournRec`. Points are then given to the players in \n",
    "        accordance with how many matches they won.\n",
    "        \"\"\"\n",
    "        while self.round<self.numPlayers:\n",
    "            self.playRound()\n",
    "            self.permute()\n",
    "        self.tournRes = pd.DataFrame(self.matchRec,columns=[\"Round\", \"Match\",\"player1_id\",\"player1_rnkPoints\",\"player1_perform\",\"player2_id\",\"player2_rnkPoints\",\"player2_perform\",\"winner_id\"])\n",
    "        self.winLossRec.sort_values(by=[\"Wins\",\"Diff\"],ascending=[False,False],inplace=True)\n",
    "        self.distributePoints()\n",
    "        \n",
    "    def distributePoints(self):\n",
    "        \"\"\"\n",
    "        A method to distribute the points.\n",
    "        \n",
    "        For each match a player has won, the value that is stored in the corresponding entry of :py:attr:`winLossRec`, they will gain points equal \n",
    "        to :py:attr:`pointPerWin`.\n",
    "        \"\"\"\n",
    "        for py in self.playerList:\n",
    "            py.gainPoints(int(self.winLossRec.loc[py.name,\"Wins\"])*self.pointPerWin)\n",
    "    \n",
    "    def reset(self):\n",
    "        \"\"\"\n",
    "        A method to reset the tournament.\n",
    "        \"\"\"\n",
    "        self.matchRec=[]\n",
    "        self.tournRes=None\n",
    "        self.round=1\n",
    "        \n",
    "        names=[]\n",
    "        for py in self.playerList:\n",
    "            names.append([py.name,0,0,0])\n",
    "        self.winLossRec = pd.DataFrame(names,columns=[\"Player\",\"Wins\",\"Losses\",\"Diff\"])\n",
    "        self.winLossRec.set_index(\"Player\",inplace=True)\n",
    "            \n",
    "class bye(player):\n",
    "    \"\"\"\n",
    "    A class to model a bye.\n",
    "    \n",
    "    In some tournaments there are not enough player, so the empty spots are filled up with a bye. Whenever a player is against a bye they automatically win.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        super().__init__(-1,0,\"Bye\",0)\n",
    "    \n",
    "    def perform(self):\n",
    "        return self.skill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting package/synthSportPlayer/utils.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile package/synthSportPlayer/utils.py\n",
    "import pandas as pd\n",
    "def getPlayerHist(pid,df):\n",
    "    \"\"\"\n",
    "    A function to get all the matches of a given player that reside in the provided dataframe. \n",
    "    Will work on individual tournament results or on concatenated season results.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    pid : str\n",
    "          The name of the player whose match results are to be searched for. This should be the players '.name' atrribute\n",
    "    df : DataFrame\n",
    "         The DataFrame that contains match results\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    pid_df : DataFrame\n",
    "             A DataFrame that contains match results that the given player has participated in.\n",
    "    \"\"\"\n",
    "    if type(pid)!=str:\n",
    "        raise TypeError(\"pid must be a str\")\n",
    "    if type(df)!=pd.core.frame.DataFrame:\n",
    "        raise TypeError(\"df must be a pandas dataframe\")\n",
    "        \n",
    "    tk1='player1'\n",
    "    tk2='player2'\n",
    "    other = [x for x in list(df.columns) if not(\"_\" in x)]\n",
    "    ext = list(set([y.split('_')[1] for y in [x for x in list(df.columns) if (\"_\" in x)]]))\n",
    "    \n",
    "    pid_df = df[(df[tk1+'_id']==pid)]\n",
    "    pid_df.winner_id=(pid_df[\"winner_id\"]==pid)\n",
    "    pid_df.rename(columns=dict(zip([tk1+\"_\"+x for x in ext]+[tk2+\"_\"+x for x in ext],\n",
    "                                   [\"player_\"+x for x in ext]+[\"opponent_\"+x for x in ext])),inplace=True)\n",
    "\n",
    "    pid2_df = df[(df[tk2+'_id']==pid)]\n",
    "    pid2_df.winner_id=(pid2_df[\"winner_id\"]==pid)\n",
    "    pid2_df.rename(columns=dict(zip([tk2+\"_\"+x for x in ext]+[tk1+\"_\"+x for x in ext],\n",
    "                                    [\"player_\"+x for x in ext]+[\"opponent_\"+x for x in ext])),inplace=True)\n",
    "\n",
    "    pid_df = pd.concat([pid_df,pid2_df])\n",
    "    if \"Tourn\" in other:\n",
    "        pid_df.sort_values(by=[\"Tourn\",\"Round\",\"Match\"],ascending=[False,False,True],inplace=True)\n",
    "    else:\n",
    "        pid_df.sort_values(by=[\"Round\",\"Match\"],ascending=[False,True],inplace=True)\n",
    "\n",
    "    return pid_df\n",
    "\n",
    "def getMatchUpData(pid1,pid2,df):\n",
    "    \"\"\"\n",
    "    A function to get all the matches between two players that reside in the provided dataframe. \n",
    "    Will work on individual tournament results or on concatenated season results.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    pid1 : str\n",
    "          The name of a player whose match results are to be searched for. This should be the players '.name' atrribute\n",
    "    pid2 : str\n",
    "          The name of the other player whose match results are to be searched for. This should be the players '.name' atrribute\n",
    "    df : DataFrame\n",
    "         The DataFrame that contains match results\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    mu_df : DataFrame\n",
    "             A DataFrame that contains match results that the two player has participated in against each other.\n",
    "    \"\"\"\n",
    "    if type(pid1)!=str:\n",
    "        raise TypeError(\"pid1 must be a str\")\n",
    "    if type(pid2)!=str:\n",
    "        raise TypeError(\"pid2 must be a str\")\n",
    "    if type(df)!=pd.core.frame.DataFrame:\n",
    "        raise TypeError(\"df must be a pandas dataframe\")\n",
    "        \n",
    "    mu_df = df[((df[\"player1_id\"]==pid1)&(df[\"player2_id\"]==pid2)|(df[\"player1_id\"]==pid2)&(df[\"player2_id\"]==pid1))]\n",
    "    \n",
    "    if \"Tourn\" in mu_df.columns:\n",
    "        mu_df.sort_values(by=[\"Tourn\",\"Round\",\"Match\"],ascending=[False,False,True],inplace=True)\n",
    "    else:\n",
    "        mu_df.sort_values(by=[\"Round\",\"Match\"],ascending=[False,True],inplace=True)\n",
    "\n",
    "    return mu_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}