tournament.py

#!/usr/bin/env python
#
# tournament.py -- implementation of a Swiss-system tournament
#

import psycopg2


def connect():
    """Connect to the PostgreSQL database.  Returns a database connection."""
    return psycopg2.connect("dbname=tournament")


def deleteMatches():
    """Remove all the match records from the database."""
    db = connect()
    c = db.cursor()
    c.execute("DELETE FROM matches")
    db.commit()
    db.close();


def deletePlayers():
    """Remove all the player records from the database."""
    db = connect()
    c = db.cursor()
    c.execute("DELETE FROM players")
    db.commit()
    db.close();


def countPlayers():
    """Returns the number of players currently registered."""
    db = connect()
    c = db.cursor()
    c.execute("SELECT count(id) FROM players")
    rows = c.fetchall()
    db.close()
    return rows[0][0];

def registerPlayer(name):
    """Adds a player to the tournament database.

    The database assigns a unique serial id number for the player.  (This
    should be handled by your SQL database schema, not in your Python code.)

    Args:
      name: the player's full name (need not be unique).
    """
    db = connect()
    c = db.cursor()
    c.execute("INSERT INTO players (name) VALUES (%s)", (name,))
    db.commit()
    db.close();


def playerStandings():
    """Returns a list of the players and their win records, sorted by wins.

    The first entry in the list should be the player in first place, or a player
    tied for first place if there is currently a tie.

    Returns:
      A list of tuples, each of which contains (id, name, wins, matches):
        id: the player's unique id (assigned by the database)
        name: the player's full name (as registered)
        wins: the number of matches the player has won
        matches: the number of matches the player has played
    """
    db = connect()
    c = db.cursor()
    c.execute("SELECT matches.id, win_record FROM matches, standings GROUP BY win_record;")
    rows = c.fetchall()
    db.close()
    return rows


def reportMatch(winner,loser):
    """Records the outcome of a single match between two players.

     Args:
       winner:  the id number of the player who won
       loser:  the id number of the player who lost
     """

    db = connect()
    c = db.cursor()
    c.execute("INSERT INTO MATCHES (winner,loser) VALUES (%s,%s)", (winner,loser,))
    db.commit()
    db.close();


# def swissPairings():
    """Returns a list of pairs of players for the next round of a match.

    Assuming that there are an even number of players registered, each player
    appears exactly once in the pairings.  Each player is paired with another
    player with an equal or nearly-equal win record, that is, a player adjacent
    to him or her in the standings.

    Returns:
        A list of tuples, each of which contains (id1, name1, id2, name2)
         id1: the first player's unique id
         name1: the first player's name
         id2: the second player's unique id
         name2: the second player's name
     """

    db = connect()
    c = db.cursor()
    c.execute("SELECT id, name, win_record FROM Standings ORDER BY win_record;")
    rows = c.fetchall()
    db.close()
    i = 0
    pairings = []
    while i < len(rows):
      player1id = rows[i][0]
      players1name = rows[i][i]
      player2id = rows[i +1][0]
      player2name = rows[i+1][i]
      pairings.append((player1id, players1name, player2id, player2name))
      i = i + 2

    return pairings




# def swissPairings():
# 111     """Returns a list of pairs of players for the next round of a match.
# 112
# 113     Assuming that there are an even number of players registered, each player
# 114     appears exactly once in the pairings.  Each player is paired with another
# 115     player with an equal or nearly-equal win record, that is, a player adjacent
# 116     to him or her in the standings.
# 117
# 118     Returns:
# 119       A list of tuples, each of which contains (id1, name1, id2, name2)
# 120         id1: the first player's unique id
# 121         name1: the first player's name
# 122         id2: the second player's unique id
# 123         name2: the second player's name
# 124     """
# 125     standings = multipleResultQuery("SELECT id, name from standings;")
# 126

# 127     """Determining the matches to be played according to players' rankings in the standings view.
# 128     Iterating through the standings view 2 players at a time and returning their information."""
# 129

# 130     pairs = []
# 131     total_players = len(standings)
# 132     for i in range(0, total_players, 2):
# 133         pairs.append(standings[i] + standings[i+1])
# 134     return pairs