def setUp(self) -> None:
num_routes = 7
routes = ['r{}'.format(i) for i in range(1, num_routes + 1)]
self.test_election = ElectionResult(
routes, [
Voter('Ike', ['r1', 'r6', 'r2', 'r3', 'r5', 'r4', 'r7']),
Voter('Jochem', ['r3', 'r4', 'r6', 'r1', 'r2', 'r7', 'r5']),
Voter('Jesse', ['r2', 'r1', 'r5', 'r3', 'r4', 'r7', 'r6']),
Voter('Piotr', ['r3', 'r5', 'r2', 'r4', 'r7', 'r1', 'r6']),
Voter('Melina', ['r4', 'r1', 'r5', 'r6', 'r3', 'r2', 'r7']),
]
)
def __init__(self, user, postingKey):
self.steem = Steem(keys=[postingKey], nodes=steemd_nodes)
self.user = user
self.voter = Voter(self.steem, user)
self.last_update_duration = 0
super().__init__(None)
self.daemon = True
def election_result_from_file(filename: str):
with open(filename, newline='') as csvFile:
data_list = list(csv.DictReader(csvFile))
# simplify the route names
old_keys = list(data_list[0].keys())
new_keys = old_keys.copy()
for i, key in enumerate(new_keys):
new_keys[i] = key.replace('Which route would you prefer? Pick an order in which you prefer routes. '
'MAKE SURE THAT YOU RANK ALL ROUTES AT DIFFERENT PRIORITIES. ', '')
routes = new_keys[2:]
# update all keys (=questions) for the enquete answers
for row in data_list:
for i in range(len(new_keys)):
row[new_keys[i]] = row.pop(old_keys[i])
voters = []
for row in data_list:
name = row['What is your name?']
ranking = ['']*12
for route in row:
if route == 'Tijdstempel' or route == 'What is your name?' :
continue
route_index = int(row[route][:-7]) - 1
ranking[route_index] = route
if has_empty_element(ranking):
raise Exception("Input is wrong or interpretation is wrong. Ranking of voter {} has empty element."
.format(name))
voter = Voter(name, ranking)
voters.append(voter)
return ElectionResult(routes, voters)
def generate_voter_instances(self, submissions):
all_voters = []
for submission in submissions:
voter_data = self.client.get_submission_details(submission)
voter = Voter(voter_data['first_name'], voter_data['last_name'], voter_data['views'], voter_data['submission_id'])
all_voters.append(voter)
return all_voters
def register(min_age = 18,city= 'New Brunswick',state= 'NJ') -> None:
print('---------Voter Registration---------\n')
first_name = input("Enter First Name: ").upper()
last_name = input("Enter Last Name: ").upper()
dob = get_dob()
age = (datetime.date.today() - dob).days/365
print(age)
if age < min_age:
print("Too Young to Register")
return
address = get_address()
#FOR now voter id will just be a numbering system
with open('voterid.txt','r') as file:
voter_id = int(file.readline())
voter_id += 1
with open('voterid.txt','w') as file:
file.write(str(voter_id))
registered_voter = Voter(voter_id,first_name,last_name,dob,address)
with open('voters.csv','a') as file:
writer = csv.writer(file, delimiter = ',')
writer.writerow([str(voter_id),repr(registered_voter)])
def create_voters_from_input_data():
rows = load_csv(URL_INPUT_CSV)
if rows is None:
return
for row in rows:
input_voter_list.append(
Voter(row['row'], row['name'], row['birth_year'], row['address'],
row['city'], row['state'], row['zip']))
return input_voter_list
def _convert_dataset_into_id2voter(cls, dataset,
possible_indecision_levels):
""" Convert a Dataset object into a id2voter """
voter_id_count = 0
id2voter = dict()
for strict, count in zip(dataset.preferences, dataset.counts):
for _ in range(count):
partial = PartialOrder.generate_from_strict(
strict, np.random.choice(possible_indecision_levels))
voter = Voter(partial, strict)
id2voter[voter_id_count] = voter
voter_id_count += 1
return id2voter
def submit_vote():
message = 'Success!'
try:
t = ClientTallier(random.choice(tallier_endpoints))
voter = Voter(session['username'], r, t, e)
success = voter.vote(request.form['evote'], json.loads(request.form['proof']))
if not success:
message = "Something went wrong, please try again"
except Exception:
message = 'Something went wrong, please try again'
return message
def voter_register():
username = request.form['username']
password = request.form['password']
voter = Voter.getVoter({'username': username})
if voter is None:
voter = Voter(username=username, password=password)
voter.addVoter()
session['voter'] = username
return redirect(url_for('home'))
else:
return redirect(url_for('login'))
def voter_register():
username = request.form['username']
password = request.form['password']
voter = Voter.getVoter({'username':username})
if voter is None:
voter = Voter(username = username, password = password)
voter.addVoter()
session['voter'] = username
flash('Registration successful. Update profile', 'info')
return redirect(url_for('home'))
else:
flash('You need to Login first!', 'warning')
return redirect(url_for('login'))
def populate_from_spreadsheet(self, input_file_name):
"""
Grab voter data from the given spreadsheet
(prepared by create_spreadsheet_from_voter_dictionary in create-voter-spreadsheet.py)
and populate the Contest with the relevant Voters and Entries.
"""
if self.verbose:
print(f"Populating contest with voter data from {input_file_name}...",
end="", flush=True)
with open(input_file_name, "r", newline="") as spreadsheet:
reader = csv.reader(spreadsheet, delimiter=",")
header = next(reader)
entry_names = header[1:]
# If there n Entries, each voter can assign at most n distinct rankings.
# (Really the number of Entries may be more than the number of distinct rankings.
# For example, a poll could ask users to vote for the top 3 Entries out of 10.
# It's fine to overestimate the number of distinct rankings though. It'll just lead to
# some wasted space in each Voter, which doesn't really matter.)
num_distinct_rankings = len(entry_names)
# construct Entries
for entry_name in entry_names:
# self.entries[i] contains the entry from column i+1
# (not column i because the leftmost column contains user info, not entry info)
self.entries.append(Entry(entry_name))
# construct Voters and record their votes
for row in reader:
voter_name = row[0]
# voter_rankings[i] contains the voter's ranking for entry self.entries[i]
voter_rankings = row[1:]
voter = Voter(voter_name, num_distinct_rankings)
for i, ranking in enumerate(voter_rankings):
if ranking:
# the ranks are stored in user_rankings as a list of strings, so cast them
# to ints for use as indexes
voter.rank(self.entries[i], int(ranking))
self.voters.append(voter)
if self.verbose:
print(" done.")
def create_voter(self):
print 'Alright, let\'s create a voter'
first_name = raw_input('What is the voter\'s first name?').lower().capitalize()
last_name = raw_input('Ok, what is the voter\'s last name?').lower().capitalize()
print 'For this survey, please select one of the following views:'
for view in self.VALID_VIEWS:
print view
views = raw_input().lower().capitalize()
voter = Voter(first_name, last_name, views)
response = self.submit_vote(first_name, last_name, views)
if response == 200:
print 'Submitting your survey. Please wait...'
self.submissions_list = self.client.get_submissions_list()
self.voters = self.generate_voter_instances(self.submissions_list)
print 'Survey was submitted successfully'
else:
print 'There was an error submitting your survey, please try again later.'
return
def submit_vote():
message = 'Success!'
try:
e, tallier_endpoints = r.get_election(int(request.form['eid']))
if not e:
message = 'Invalid Election ID'
return render_template('voting_interface.html',
submit_vote_msg=message)
t = ClientTallier(random.choice(tallier_endpoints))
voter = Voter(request.form['voter_id'], r, t, e)
success = voter.vote(request.form['candidate'])
if not success:
message = 'Vote not cast: your vote was either invalid or already cast'
except Exception:
message = 'Something went wrong, please try again'
return render_template('voting_interface.html', submit_vote_msg=message)
def fake_voter(self):
fake = Faker('es_MX')
select = (
"SELECT electoral_key FROM user ORDER BY electoral_key DESC LIMIT 70"
)
self.cursor.execute(select)
result = self.cursor.fetchall()
for row in result:
create_voter = Voter(self.connection, self.cursor)
electoral_key = row[0]
name = fake.first_name()
middle_name = fake.first_name()
flastname = fake.last_name()
mlastname = fake.last_name()
address = fake.simple_profile(sex=None)['address']
birth_date = fake.simple_profile(sex=None)['birthdate']
create_voter.create(electoral_key, name, middle_name, flastname,
mlastname, address, birth_date)
return ("OK")
def create_voters(self):
self.voters = []
for i in range(self.voter_count):
self.voters.append(Voter(self))
r_endpoint = entity_locations.get_registrar_endpoint()
r = ClientRegistrar(r_endpoint)
eid = r.register_election(voter_ids, candidates)
print("Got Election ID", eid)
if eid == False:
print("Could not get an election")
sys.exit(0)
e, tallier_endpoints = r.get_election(eid)
print("Connected to Talliers:")
for endpoint in tallier_endpoints:
print(endpoint.hostname, str(endpoint.port))
voters = [
Voter(voter_ids[i], r,
ClientTallier(tallier_endpoints[i % len(tallier_endpoints)]), e)
for i in range(NUM_VOTERS)
]
expected_vote_totals = {candidates[i]: 0 for i in range(NUM_CANDIDATES)}
current_votes = 0
for voter in voters:
candidate = candidates[random.randint(0, NUM_CANDIDATES - 1)]
expected_vote_totals[candidate] += 1
voter.vote(candidate)
if current_votes % FREQUENCY == 0:
print("Completed Processing Vote:", current_votes)
current_votes += 1
r.end_election(eid)
def get_random_voter_on(routes):
random_name = ''.join(choices(string.ascii_uppercase + string.digits, k=7))
return Voter(random_name, sample(routes, k=5))
def generate_voters(self, n):
for i in range(n):
self.voters.append(Voter(self))
self.log.write("Created {} voters".format(n, "d"))
# progress bar
with tqdm(total=args.experiments**2, leave=False) as pbar:
for _ in range(args.experiments):
id2voter = {}
random.shuffle(all_types)
type_list = all_types[:type_num]
for i in range(type_num):
t = type_list[i]
for j in range(i * args.clique_size, (i + 1) * args.clique_size):
strict = generator.generate(list(t))
# strict = list(t)
partial = PartialOrder.generate_from_strict(strict, random.choice(possible_indecision_levels))
voter = Voter(partial, strict)
id2voter[j] = voter
SN = SocialNetwork(strategy='from_voter_graph', id2voter=id2voter, graph=graph)
true_preferences, true_counts = get_counts(id2voter)
for _ in range(args.experiments):
for paradigm in paradigms:
# get the preferences
SN_preferences, SN_counts = SN.get_preferences(paradigm)
# and get the winner for every rule
for rule in VotingRules.rules:
# this corresponds to random tie breaking
def __init__(self, Voter_id):
self.key = hashlib.sha256(Voter_id.encode('utf-8')).hexdigest()
self.voter = Voter(self.key)
def _generate_voters(self):
for i in range(NUM_OF_VOTER):
short_private_key = UmbralPrivateKey.gen_key()
short_public_key = short_private_key.get_pubkey()
voter = Voter(short_public_key, short_private_key)
self.voters.append(voter)
def test_decide_vote_should_return_null(self):
voter = Voter('first_name', 'last_name', 'Liberal', '12345')
voter.decide_vote(mocked_democrat_for_null, 0.99)
self.failUnless(voter.vote == 'null')
def test_decide_vote_should_return_democrat(self):
voter = Voter('first_name', 'last_name', 'Liberal', '12345')
voter.decide_vote(mocked_democrat, 0.70)
self.failUnless(voter.vote == 'Democrat')
def test_decide_vote_should_return_republican(self):
voter = Voter('first_name', 'last_name', 'Liberal', '12345')
voter.decide_vote(mocked_republican, 0.20)
self.failUnless(voter.vote == 'Republican')
def __init__(self, user, postingKey): self.client = Hive(keys=[postingKey],nodes=config.nodes) self.user = user self.voter = Voter(self.client, config.nodes, user) self.last_update_duration = 0
from results import Results
from voter import Voter
import json
# with open('results.json', 'r') as f:
# date = json.load(f)
# for p in date:
# my_result = Results(p['Center Name'], p['Center Number'], p['Valid Votes'], None)
# my_result.save_to_db()
#
# my_result = Voter('1', '2', '3', '4', '2018-09-15 ', '6', '7', '8', '9', '10', 1212, '12', 212, 21, None)
# my_result.save_to_db()
my_result = Voter('1', '2', '3', None)
my_result.save_to_db()
