stv

    QUOTA ="!QUOTA"

        self.candidates = candidates

                print "Missing value for random selection among ", collected

def redistribute_ballots(selected, weight, hopefuls, allocated, vote_count):

    The total ballot allocation is given by the allocated map, which

    is modified accordingly. The current vote count is given by

    vote_count and is adjusted according to the redistribution.

def elect_reject(candidate, vote_count, constituencies, quota_limit,

                 current_round, elected, rejected, constituencies_elected):

    """Elects or rejects the candidate, based on quota restrictions.

    If there are no quota limits, the candidate is elected. If there

    are quota limits, the candidate is either elected or rejected, if

    the quota limits are exceeded. The elected and rejected lists

    are modified accordingly, as well as the constituencies_elected map.

    Returns true if the candidate is elected, false otherwise.

    """

    logger = logging.getLogger(SVT_LOGGER)

    quota_exceeded = False

    # If there is a quota limit, check if it is exceeded

    if quota_limit > 0 and candidate in constituencies:

        current_constituency = constituencies[candidate]

        if constituencies_elected[current_constituency] >= quota_limit:

            quota_exceeded = True

    # If the quota limit has been exceeded, reject the candidate

    if quota_exceeded:

        rejected.append((candidate, current_round, vote_count[candidate]))

        d = candidate + " = " + str(vote_count[candidate])

        msg = LOG_MESSAGE.format(action=Action.QUOTA, desc=d)

        logger.info(msg)

        return False

    # Otherwise, elect the candidate

    else:

        elected.append((candidate, current_round, vote_count[candidate]))

        if constituencies:

            current_constituency = constituencies[candidate]

            constituencies_elected[current_constituency] += 1

        d = candidate + " = " + str(vote_count[candidate])

        msg = LOG_MESSAGE.format(action=Action.ELECT, desc=d)

        logger.info(msg)

        return True

def count_stv(ballots, seats, droop = True, constituencies = None,

              quota_limit = 0, rnd_gen=None):

    """Performs a STV vote for the given ballots and number of seats.

    If droop is true the election threshold is calculated according to the

    Droop quota:

            threshold = int(1 + (len(ballots) / (seats + 1.0)))

    otherwise it is calculated according to the following formula:

            threshold = int(math.ceil(1 + len(ballots) / (seats + 1.0)))

    The constituencies argument is a map of candidates to constituencies, if

    any. The quota_limit, if different than zero, is the limit of candidates

    that can be elected by a constituency.

    # The candidates that have been eliminated because of low counts

    eliminated = []

    # The candidates that have been eliminated because of quota restrictions

    rejected = []

    # The number of candidates elected per constituency

    constituencies_elected = {}

    for constituency in constituencies.values():

        constituencies_elected[constituency] = 0

        threshold = int(1 + (len(ballots) / (seats + 1.0)))

        # If there is a surplus record it so that we can try to

        # redistribute the best candidate's votes according to their

        # next preferences

        # If there is either a candidate with surplus votes, or

        # there are hopeful candidates beneath the threshold.

        if surplus >= 0 or num_hopefuls <= (seats - num_elected):

            if best_candidate not in hopefuls:

                print "Not a valid candidate: ",best_candidate

                sys.exit(1)

            was_elected = elect_reject(best_candidate, vote_count,

                                       constituencies, quota_limit,

                                       current_round, 

                                       elected, rejected,

                                       constituencies_elected)

            if not was_elected:

                redistribute_ballots(best_candidate, 1.0, hopefuls, allocated,

                                     vote_count)

                redistribute_ballots(best_candidate, weight, hopefuls,

                                     allocated, vote_count)

        # If nobody can get elected, take the least hopeful candidate

            eliminated.append(worst_candidate)

            d = worst_candidate + " = " + str(vote_count[worst_candidate])

            msg = LOG_MESSAGE.format(action=Action.ELIMINATE, desc=d)

            logger.info(msg)

            redistribute_ballots(worst_candidate, 1.0, hopefuls, allocated,

    # If there is either a candidate with surplus votes, or

    # there are hopeful candidates beneath the threshold.

    while (seats - num_elected) > 0 and len(eliminated) > 0:

        best_candidate = eliminated.pop()

        elect_reject(best_candidate, vote_count, constituencies,

                     quota_limit, current_round,

                     elected, rejected, constituencies_elected)

        current_round += 1

    parser.add_argument('-c', '--constituencies',

                        dest='constituencies_file',

                        help='input constituencies file')

    parser.add_argument('-q', '--quota', type=int, default=0,

                        dest='quota', help='constituency quota')

                                skipinitialspace=True)

    constituencies = {}

    if args.constituencies_file:

        constituencies_file = open(args.constituencies_file, 'U')

        constituencies_reader = csv.reader(constituencies_file,

                                           delimiter=',',

                                           quotechar='"',

                                           skipinitialspace=True)

        constituency_id = 0

        for constituency in constituencies_reader:

            for candidate in constituency:

                constituencies[candidate] = constituency_id

            constituency_id += 1

    (elected, vote_count) = count_stv(ballots, args.seats, args.droop,

                                      constituencies,

                                      args.quota,