def test_get_results(self):
poll = Poll("test", "fake id")
poll.add_option(None, ["option #1", "This is the first option"])
poll.add_option(None, ["option #2", "This is the second option"])
poll.start_poll()
for i in range(1333):
choice = i % 3 != 0
option = "1" if choice else "2"
poll.submit_vote(str(i), str(i) + " name", [option])
self.assertEqual(
poll.get_results(), """The winner is: option #1
option #1: 67% 888 votes
option #2: 33% 445 votes
Total votes: 1333""")
poll2 = Poll("test", "fake id")
poll2.add_option(None, ["option #1", "This is the first option"])
poll2.add_option(None, ["option #2", "This is the second option"])
poll2.start_poll()
for i in range(100):
choice = i % 2 != 0
option = "1" if choice else "2"
poll2.submit_vote(str(i), str(i) + " name", [option])
self.assertEqual(
poll2.get_results(), """Its a Tie!
option #1: 50% 50 votes
option #2: 50% 50 votes
Total votes: 100""")
def test_get_polls_with_options_returns_poll_with_correct_options(self):
test_poll = Poll("options_test")
test_poll.add_options_from_list(
[PollOption("first"),
PollOption("second"),
PollOption("third")])
test_poll2 = Poll("second_test")
test_poll2.add_options_from_list(
[PollOption("fourth"),
PollOption("fifth"),
PollOption("sixth")])
self.db.add_poll(test_poll)
self.db.add_poll(test_poll2)
output = self.db.get_polls_with_name("options_test")
self.assertEqual(len(output), 1)
self.assertEqual(len(output[0].poll_options),
len(test_poll.poll_options))
for actual, expected in zip(output[0].poll_options,
test_poll.poll_options):
self.assertEqual(actual.name, expected.name)
output = self.db.get_polls_with_name("second_test")
self.assertEqual(len(output), 1)
self.assertEqual(len(output[0].poll_options),
len(test_poll2.poll_options))
for actual, expected in zip(output[0].poll_options,
test_poll2.poll_options):
self.assertEqual(actual.name, expected.name)
def __init__(self):
self.client = zulip.Client(site="https://chunkzz.zulipchat.com/api/")
self.subscribe_all()
self.chatbot = ChatBot(
"Omega", trainer='chatterbot.trainers.ChatterBotCorpusTrainer')
self.chatbot.train("chatterbot.corpus.english")
self.crypto = Crypto()
self.trans = Translate()
self.g = Giphy()
self.w = WikiPedia()
self.tw = Twimega()
self.motivate = Motivate()
self.shortenedurl = Urlshortener()
self.hacknews = Hackernews()
self.geo = Geocode()
self.weather = Weather()
self.dict_ = Dictionary()
self.joke = Joke()
self.pnr = Pnr()
self.mustread = Mustread()
self.ss = Ss()
self.cricket = Cricket()
self.poll = Poll()
self.subkeys = [
"crypto", "translate", "define", "joke", "weather", "giphy", "pnr",
"mustread", "poll", "hackernews", "hn", "HN", "motivate",
"twitter", "screenshot", "memo", "cricnews", "help", "shorturl"
]
def ExtractPollsFromTable(table, riding_number, riding_name):
polls = []
rows = table.find_all('tr')
date_column, sample_size_column, party_columns = FindColumnHeaders(rows[0])
for row in rows[1:]:
columns = row.find_all('td')
date_string = columns[date_column].find('span', '').get_text()
parsed_date = datetime.datetime.strptime(date_string, '%B %d, %Y')
sample_size_string = columns[sample_size_column].get_text().strip()
if sample_size_string:
sample_size = float(sample_size_string.replace(',', ''))
else:
sample_size = 0
poll = Poll(parsed_date, sample_size, riding_number, riding_name)
for party_name, party_index in party_columns.items():
if party_index >= 0:
number_string = columns[party_index].get_text()
try:
support = float(number_string) / 100
except:
support = 0
party_code = party_names[party_name]
poll.party_support[party_code] = support
polls.append(poll)
return polls
def test_add_option(self):
poll = Poll("test", "fake id")
poll.add_option(None, ["option #1", "This is the first option"])
self.assertEqual(
str(poll), r"test{'option #1': {'id': 'option #1', 'description'"
r": 'This is the first option', 'voters': [], 'index'"
r": 0}}{}fake id")
def __init__(self, curr_directory, output_directory, max_file_size,
plugins_file, es_url):
"""Initializes the Efetch Helper"""
# Setup directory references
self.curr_dir = curr_directory
self.resource_dir = self.curr_dir + os.path.sep + u'resources' + os.path.sep
self.icon_dir = self.resource_dir + u'icons' + os.path.sep
self.output_dir = output_directory
self.max_file_size = max_file_size
if not os.path.isdir(self.icon_dir):
logging.error(u'Could not find icon directory ' + self.icon_dir)
self.pathspec_helper = PathspecHelper(output_directory, max_file_size)
# Create plugin manager and begin polling for changes to plugins
self.plugin_manager = EfetchPluginManager(plugins_file, self.curr_dir)
self.poll = Poll(self.plugin_manager)
self.poll.start()
self.standard_office_2007_extensions = [
'xlsx', 'docx', 'pptx', 'dotx', 'docm', 'doct', 'xlsm', 'xltx',
'xltm', 'pptx', 'pptm', 'potx', 'ppam', 'ppsx', 'ppsm', 'sldx',
'sldm'
]
# Elastic Search DB setup
if es_url:
self.db_util = DBUtil()
else:
self.db_util = DBUtil(es_url)
def handler(event, contest):
logger.info("Start!")
main_loop = IOLoop.instance()
poll = Poll(main_loop)
cal = poll.cal
delete = Delete()
update_and_delete = UpdateAndDelete(main_loop, delete)
table = event['table']
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs_receive_message, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
update_and_delete.execute(sqs_delete_message_batch, db_update_item,
queue_url, table, cal.stats)
logger.info("Update API count: {}".format(update_and_delete.update_count))
logger.info("Delete API count: {}".format(delete.delete_count))
logger.info("Delete Message count: {}".format(delete.message_count))
return "Lambda job finished successfully."
def __init__(self):
self.client = zulip.Client(site="https://fazeup.zulipchat.com/api/")
self.subscribe_all()
self.hacknews = Hackernews()
self.trans = Translate()
self.movie = Movie()
self.lyrics = Lyrics()
self.holiday = Holiday()
self.currency = Currency()
self.cricket = Cricket()
# self.chatbot.train("chatterbot.corpus.english")
self.crypto = Crypto()
self.trans = Translate()
self.g = Giphy()
self.w = WikiPedia()
# self.tw = Twimega()
# self.motivate = Motivate()
self.shortenedurl = Urlshortener()
self.geo = Geocode()
self.weather = Weather()
self.dict_ = Dictionary()
self.joke = Joke()
self.pnr = Pnr()
self.mustread = Mustread()
self.ss = Ss()
self.cricket = Cricket()
self.poll = Poll()
print("done init")
self.subkeys = [
"crypto", "translate", "define", "joke", "weather", "giphy", "pnr",
"mustread", "poll", "hackernews", "hn", "HN", "motivate",
"twitter", "screenshot", "memo", "cricnews", "help", "shorturl",
"movie", "currency", "holiday", "lyrics"
]
def test_get_polls_ID_values_match_as_expected(self):
test_poll = Poll("poll")
self.db.add_poll(test_poll)
output = self.db.get_polls_with_name("poll")
self.assertEqual(len(output), 1)
self.assertEqual(output[0].id, test_poll.id)
def test_get_polls_name_exists_returns_poll(self):
self.db.add_poll(Poll("poll"))
output = self.db.get_polls_with_name("poll")
self.assertEqual(len(output), 1)
self.assertTrue(output[0].name == "poll")
def handler(event, contest):
logger.info("Start!")
executor = ThreadPoolExecutor(max_workers=1000)
main_loop = asyncio.new_event_loop()
main_loop.set_default_executor(executor)
asyncio.set_event_loop(main_loop)
poll = Poll(main_loop)
cal = poll.cal
update_and_delete = UpdateAndDelete(main_loop, executor)
table = event['table']
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
update_and_delete.execute(sqs_client, db, queue_url, table, cal.stats)
logger.info("Update API count: {}".format(update_and_delete.update_count))
logger.info("Delete API count: {}".format(update_and_delete.delete_count))
logger.info("Delete Message count: {}".format(
update_and_delete.deleted_message_count))
main_loop.close()
executor.shutdown()
return "Lambda job finished successfully."
def test_load_invalid():
with pytest.raises(InvalidPollError):
Poll.load('bla')
with pytest.raises(InvalidPollError):
poll = Poll.create('user0123', 'Spam?', 'en', ['Yes', 'Maybe', 'No'],
secret=True, public=True, max_votes=2)
Poll(poll.connection, 'user3210')
def prompt_create_poll():
poll_title = input("Enter poll title: ")
poll_owner = input("Enter poll owner: ")
poll = Poll(title=poll_title, owner=poll_owner)
poll.save()
while (new_option := input(NEW_OPTION_PROMPT)):
poll.add_option(new_option)
def gmail():
if request.method == "GET":
return render_template("email.html")
elif request.method == "POST":
form = request.form
something = form["something"]
p = Poll(something=something)
p.save()
return render_template("email.html")
def return_matches(list_of_token):
httpretty.enable()
add_fixtures()
result = Poll().matches(list_of_token)
first = result[0]
assert first['date'] == '2015-04-15'
teardown()
def poll_for_tests():
poll = Poll()
poll.storage = Mock()
poll.storage.data = {
'is_started': False,
'is_music_upload': False,
'messages': []
}
return poll
def test_submit_vote(self):
poll = Poll("test", "fake id")
poll.add_option(None, ["option #1", "This is the first option"])
poll.add_option(None, ["option #2", "This is the second option"])
poll.start_poll()
poll.submit_vote("test pollr id", "test name", ["1"])
self.assertEqual(
str(poll.voters), r"{'test pollr id': test pollr id "
r"test name option #1}")
def aggregate_polls(self, to_date, num_days, logger):
relevant_polls = []
from_date = to_date - dt.timedelta(days=num_days)
for poll in self.polls:
if to_date >= poll.median_date >= from_date:
relevant_polls.append(poll)
results_list = {}
for poll in relevant_polls:
for party, vote in poll.results.iteritems():
results_list[party] = np.round(
np.sum(
np.trim_zeros(
np.array([
self.weights[poll.pollster]
for poll in relevant_polls
]) * np.array([
exp_decay(to_date - poll.median_date, num_days)
for poll in relevant_polls
]) * np.array([
poll.results[party] for poll in relevant_polls
])) /
(np.array([
self.weights[poll.pollster]
for poll in relevant_polls
]) * np.array([
exp_decay(to_date - poll.median_date, num_days)
for poll in relevant_polls
]))[np.array([
self.weights[poll.pollster]
for poll in relevant_polls
]) * np.array([
exp_decay(to_date - poll.median_date, num_days)
for poll in relevant_polls
]) * np.array(
[poll.results[party]
for poll in relevant_polls]) > 0].sum()), 2)
others = [
party for party in results_list.keys()
if party not in (Parties.ALP, Parties.LIB)
]
aggregated_poll = Poll('aggregate', 'aggregate',
(to_date - from_date) / 2, 0, results_list,
None, others)
change = sum([
aggregated_poll.results[party] for party in aggregated_poll.results
])
old_others = aggregated_poll.results[Parties.OTH]
aggregated_poll.results[Parties.OTH] = old_others - change + 100
logger.info('Aggregated {} polls: {}'.format(len(relevant_polls),
aggregated_poll.results))
return aggregated_poll
def getAPoll(self,pollquestion):
connection=dbapi2.connect(current_app.config['dsn'])
cursor=connection.cursor()
cursor.execute("""SELECT VOTENUMBER,CHOICENUMBER FROM POLLS WHERE POLLQUESTION=%s""",(pollquestion,))
temp2=cursor.fetchone()
votenumber=temp2[0]
choicenumber=temp2[1]
poll=Poll(pollquestion,creatorname)
poll.votenumber=votenumber
poll.choicenumber=choicenumber
return poll
def test_get_winner(self):
poll = Poll("test", "fake id")
poll.add_option(None, ["option #1", "This is the first option"])
poll.add_option(None, ["option #2", "This is the second option"])
poll.start_poll()
for i in range(100):
choice = i % 3 != 0
option = "1" if choice else "2"
poll.submit_vote(str(i), str(i) + " name", [option])
self.assertEqual(poll.get_winner()["id"], "option #1")
poll2 = Poll("test", "fake id")
poll2.add_option(None, ["option #1", "This is the first option"])
poll2.add_option(None, ["option #2", "This is the second option"])
poll2.start_poll()
for i in range(100):
choice = i % 2 != 0
option = "1" if choice else "2"
poll2.submit_vote(str(i), str(i) + " name", [option])
self.assertFalse(poll2.get_winner())
def pull_foreach_userid(list_of_userid):
req_urls = []
expected_urls = map(helpers.match_history_uri, list_of_userid)
httpretty.enable()
add_fixtures(lambda _, uri, __: req_urls.append(uri))
Poll().match_tokens(list_of_userid)
assert req_urls == expected_urls
teardown()
def poll_player_stats(list_of_userid):
req_urls = []
expected_urls = map(helpers.player_stats_uri, list_of_userid)
httpretty.enable()
add_fixtures(lambda _, uri, __: req_urls.append(uri))
Poll().player_stats(list_of_userid)
assert req_urls == expected_urls
teardown()
async def poll(self, ctx, title: str):
"""Create a poll with a one-word title!"""
# add check for poll with existing name
poll = Poll(title, ctx.guild.id, ctx.channel.id, ctx.author.id)
await self.get_config_from_user(ctx, poll, new_poll=True)
entries = await self.get_entries_from_user(ctx)
poll.add_entries(
entries[:poll.max_entries]) # TODO add feedback for max entries
if not self.add_poll(poll):
await ctx.send('Couldn\'t create poll')
return
await ctx.send('Poll created!', embed=self.make_poll_embed(poll, ctx))
def matches():
log('matches', 'fetching stats for %d users' % len(vars.USERS))
tokens = Poll().match_tokens(vars.USERS)
if len(tokens) == 0:
log('matches', 'no tokens, exiting')
return
matches = Poll().matches(tokens)
if len(matches) == 0:
log('matches', 'no matches, exiting')
return
log('matches', "recieved %d match tokens" % len(matches))
auth = firebase.FirebaseAuthentication(vars.SECRET, vars.EMAIL)
endpoint = firebase.FirebaseApplication(vars.FB_URL)
endpoint.authentication = auth
Push(endpoint).matches(matches)
log('matches', "pushed %d matches to firebase" % len(matches))
def pull_matches(list_of_token):
match_ids_slug = "136200860+136199918"
req_urls = []
expected_url = helpers.multi_match_uri(match_ids_slug)
httpretty.enable()
add_fixtures(lambda _, uri, __: req_urls.append(uri))
Poll().matches(list_of_token)
matches_url = req_urls[0]
assert matches_url == expected_url
teardown()
def test_load():
poll = Poll.create('user0123', 'Spam?', 'en', ['Yes', 'Maybe', 'No'],
secret=True, public=True, max_votes=2, bars=True)
# because of :memory: database, load() cannot be used directly
poll2 = Poll(poll.connection, poll.id)
assert poll.creator_id == poll2.creator_id
assert poll.message == poll2.message
assert poll.secret == poll2.secret
assert poll.public == poll2.public
assert poll.max_votes == poll2.max_votes
assert poll.vote_options == poll2.vote_options
assert poll.bars == poll2.bars
def test_poll_save_load(capsys):
""" Test saving and loading a poll """
# Test saving a poll
poll = Poll(time_length=TimeLength("hours", 5),
votes=[],
prompt="foo",
channel_id=1234)
poll.save()
assert os.path.isfile(f"{POLL_DIR}/{poll.poll_id}.json")
# Test Loading a poll
other_poll = Poll()
other_poll.load(poll.poll_id)
assert poll.poll_id == other_poll.poll_id
assert poll.expiry == other_poll.expiry
assert poll.prompt == other_poll.prompt
assert poll.choices == other_poll.choices
assert poll.votes == other_poll.votes
assert poll.channel_id == other_poll.channel_id
# Test error loading poll
with open(f"{POLL_DIR}/1234.json", "w") as stream:
stream.write("{}")
with pytest.raises(ValueError) as error:
other_poll.load("1234")
assert "Something went wrong with poll 1234" in str(error)
# Test delete
poll.delete()
other_poll.delete()
assert not os.path.isfile(poll.poll_id)
poll.delete()
assert f"Warning: {poll.poll_id} does not exist" in capsys.readouterr().out
def handler(event, contest):
logger.info("Start!")
main_loop = IOLoop.instance()
poll = Poll(main_loop)
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs_receive_message, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
def test_update_description(self):
poll = Poll("test", "fake id")
poll.add_option(None, ["option #1", "This is the first option"])
poll.add_option(None, ["option #2", "This is the second option"])
poll.update_description("option #1",
"updated first option description")
self.assertEqual(
str(poll.options),
r"{'option #1': {'id': 'option #1', 'description': "
r"'updated first option description', 'voters': [], "
r"'index': 0},"
r" 'option #2': {'id': 'option #2', 'description': "
r"'This is the second option', 'voters': [], "
r"'index': 1}}")
def autoRun(userName, password):
miui_url = 'http://www.miui.com/member.php?mod=logging&action=miuilogin'
geek_url = 'http://geek.miui.com/index.php?m=member&c=index&a=login'
opener = login(miui_url, userName, password)
dailySignIn(opener)
#geek community;1) first take the task; 2)login geek section
geekSignIn(opener)
geek_opener = login(geek_url, userName, password)
geekDraw(opener)
poller = Poll(opener)
poller.autoPoll()
