def __init__(self):
self.gml = Gmail()
self.service = self.gml.getService()
self.gcService = GContact()
self.results = self.service.users().labels().list(
userId='me').execute()
self.labels = self.results.get('labels', [])
self.hlp = Helper()
def test(self, x, y, print_report=False):
assert self.trained
predicted = self.predict(x)
self.test_array = predicted == y
self.predicted = predicted
self.tested = True
if print_report:
Helper.print_sklearn_classification_report(y, predicted,
self.classes)
return sum(self.test_array) / len(self.test_array)
def run(corpus_path):
experiment = NumericFeatures(corpus_path)
results = []
print("----------- single feature ----------")
results += experiment.single_feature()
print("-------------- pairwise -------------")
results += experiment.pairwise_feature()
print("---------------- all ----------------")
results += experiment.all_features()
Helper.analyze_results(results)
def test_login(self):
help_ = Helper(self.driver)
main = main_page.MainPage(self.driver)
print(main.get_element_offset_width())
self.assertFalse(help_.get_scrollbar_existance())
main.enter_search_text("Selenium")
main.disable_focus_from_search_field()
main.submit_search_and_wait_load()
self.assertTrue(help_.get_scrollbar_existance())
def generate_session(self, user_key: str, level: Level,
difficulty_score: float) -> str:
# Variable intended to store the key
# that will be created within the function.
session_id: int = 0
# Fetches the ids of all previously played sessions.
session_ids: [int] = self.get_session_ids(user_key)
# Checks whether at least a single session has been
# stored before for a given user.
if len(session_ids) > 0:
# Sets the id for the session that should be
# created next to one higher than previous
# session id.
session_id = max(session_ids) + 1
# Generates a key that corresponds to the previously
# created id like 'session_042' if the session's id
# is '42'
session_key: str = Helper().generate_key('session', session_id)
# Defines a new performance object which values are
# initialized with zeros.
performance: Performance = Performance(0, 0, 0, 0, 0, 0, 0,
difficulty_score)
# Creates a new session object based on the previously
# defined key and id pair.
session: Session = Session(session_key, session_id, 'created',
server_timestamp, performance)
# Defines a new database reference pointing towards
# the place at which the new session sould be stored.
ref = db.document(f'users/{user_key}/sessions/{session_key}')
# Writes the generated session to Firestore.
ref.set(session.to_dict())
# Defines a new database reference at which the session's
# performance should be stored.
ref = db.document(
f'users/{user_key}/sessions/{session_key}/data/performance')
# Stores the session's performance.
ref.set(performance.to_dict())
# Defines a new database reference pointing to the place at
# which the level for the generated session should be stored.
ref = db.document(
f'users/{user_key}/sessions/{session_key}/data/level')
# Stores the session's level at Firestore.
ref.set(level.to_dict())
# Returns the key of the generated session.
return session_key
def test(self, x, y, print_report=False):
if not self.use_text_feature:
return super(NaiveBayes, self).test(x, y, print_report)
else:
assert self.trained
predicted = self.predict(x)
test_array = []
for i in range(len(predicted)):
if predicted[i] == y[i]:
test_array.append(True)
else:
test_array.append(False)
self.predicted = predicted
self.tested = True
if print_report:
Helper.print_sklearn_classification_report(y, predicted, self.classes)
return sum(test_array)/len(test_array)
def test_generate_key(self):
helper: Helper = Helper()
self.assertEqual(helper.generate_key('user', 42), 'user_042')
self.assertEqual(helper.generate_key('session', 1), 'session_001')
self.assertEqual(helper.generate_key('user', 542), 'user_542')
self.assertEqual(helper.generate_key('session', 0), 'session_000')
class Main:
def __init__(self):
self.gml = Gmail()
self.service = self.gml.getService()
self.gcService = GContact()
self.results = self.service.users().labels().list(
userId='me').execute()
self.labels = self.results.get('labels', [])
self.hlp = Helper()
def sendEmails(self, filterLabel):
label = self.gml.getLables(self.labels, filterLabel)
unreadEmails, ids = self.gml.getTodaysColleagueNames(
self.service, label)
if not unreadEmails:
return
birthday, anniversary = self.hlp.getAllNamesFromHeaders(unreadEmails)
allContacts = self.gcService.getAllContacts()
self.hlp.sendEmailsToAll(self.service, birthday, anniversary,
allContacts)
self.hlp.markEmailAsRead(self.service, ids)
def build(packet_index, packet_id, payload_size=DEFAULT_MAX_PAYLOAD_SIZE):
"""Build ICMP package by packet_id
:param packet_index: packet index in sequence
:param packet_id:
:param payload_size:
:return: ICMP packet
"""
pre_header = struct.pack(ICMP_HEADER_FORMAT, ICMP_ECHO_REQUEST,
AUTO_VALUE, AUTO_VALUE, packet_id,
packet_index)
data = PayloadBuilder.build(payload_size)
checksum = Helper.find_checksum(pre_header + data)
header = struct.pack(ICMP_HEADER_FORMAT, ICMP_ECHO_REQUEST, AUTO_VALUE,
checksum, packet_id, packet_index)
packet = header + data
return packet
from helper.helper import Helper
if __name__ == "__main__":
helper = Helper(vae_only=True,
hidden_values=[2, 4, 8, 16, 32, 64],
reg_values=[0.1, 0.01, 0.001, 0.0001, 0.00001],
drp_values=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8],
epochs=300)
helper.train_models()
helper.make_tests()
helper.get_best_reconstruction()
helper.show_reconstrunction(vae=True,
hidden=32,
reg_val=1e-05,
drp_val=1e-01,
imgs=5)
helper.get_best_precision()
helper.get_best_recall()
helper.get_best_f1()
print(
f"Best Model Threshold is: {helper.get_th(vae=True, hidden=32, reg_val=1e-5, drp_val=0.5)}"
)
helper.get_best_svmoc()
def run(corpus_path):
experiment = TextFeatures(corpus_path, "")
result = experiment.text_only_feature()
Helper.analyze_results(result)
def submit_search_and_wait_load(self):
search_result_page = SearchResultPage()
help_ = Helper(self._driver)
help_.wait_for_element(5, self.SUBMIT_BUTTON)
self._driver.find_element(*self.SUBMIT_BUTTON).click()
help_.wait_for_element(5, search_result_page.OPTIONS_MENU)
def disable_focus_from_search_field(self):
help_ = Helper(self._driver)
help_.wait_for_element(5, self.SEARCH_INPUT)
element = self._driver.find_element(*self.SEARCH_INPUT)
self._driver.execute_script('arguments[0].blur();', element)
def enter_search_text(self, text):
help_ = Helper(self._driver)
help_.wait_for_element(5, self.SEARCH_FIELD)
element = self._driver.find_element(*self.SEARCH_INPUT)
element.send_keys(text)
def before_all(context):
context.helper = Helper()
class HelperTests(TestCase):
def setUp(self):
self.helper = Helper()
self.board = self.helper.add_board('Board Name')
def test_board(self):
self.assertEqual(self.board.name, 'Board Name')
self.assertEqual(self.board.closed, False)
self.board.close()
self.assertEqual(self.board.closed, True)
self.board.open()
self.assertEqual(self.board.closed, False)
self.assertEqual(self.board.id, 'Board Name_id')
self.assertEqual(self.board.open_lists(), [])
self.assertEqual(self.board.open_cards(), [])
self.assertEqual(self.board.get_labels(), [])
def test_list(self):
trello_list_1 = self.board.add_list('List 1')
trello_list_2 = self.board.add_list('List 2')
trello_list_3 = self.board.add_list('List 3')
self.assertEqual(self.board.open_lists(),
[trello_list_1, trello_list_2, trello_list_3])
def test_card(self):
trello_list_1 = self.board.add_list('List 1')
trello_list_2 = self.board.add_list('List 2')
trello_list_3 = self.board.add_list('List 3')
card_1 = trello_list_1.add_card('Card 1')
card_2 = trello_list_1.add_card('Card 2')
card_3 = trello_list_1.add_card('Card 3')
self.assertEqual(trello_list_1.list_cards(), [card_1, card_2, card_3])
def test_create_test_data(self):
boards = self.helper.create_test_data()
board_names = [board.name for board in boards]
expected_boards = [
'imaging', 'vector', 'claims', 'infrastructure', 'mips', 'misc',
'apps'
]
self.assertCountEqual(board_names, expected_boards)
expected_lists = {
'coding done': 7,
'qa': 7,
'in progress': 7,
'production': 7,
'final qa': 7,
'backlog': 7
}
list_counter = Counter()
for board in boards:
list_counter += Counter(
[trello_list.name for trello_list in board.open_lists()])
self.assertEqual(dict(list_counter), expected_lists)
self.assert_labels(boards)
def assert_labels(self, boards):
label_counter = Counter()
no_labels = []
for board in boards:
cards = board.open_cards()
for card in cards:
if card.labels:
label_counter += Counter(
[label.name for label in card.list_labels])
else:
no_labels.append(card)
self.assertEqual(len(no_labels), 42)
expected_labels = {
'task': 126,
'production feedback': 84,
'staging feedback': 42
}
self.assertEqual(dict(label_counter), expected_labels)
def initialize_levels(self):
database: Database = Database()
evolution: Evolution = Evolution()
level_01: Level = Level(
'level_01', '01',
TextFileReader().read_text_file('level_01.txt'))
level_02: Level = Level(
'level_02', '02',
TextFileReader().read_text_file('level_02.txt'))
level_03: Level = Level(
'level_03', '03',
TextFileReader().read_text_file('level_03.txt'))
level_04: Level = Level(
'level_04', '04',
TextFileReader().read_text_file('level_04.txt'))
level_05: Level = Level(
'level_05', '05',
TextFileReader().read_text_file('level_05.txt'))
level_06: Level = Level(
'level_06', '06',
TextFileReader().read_text_file('level_06.txt'))
level_07: Level = Level(
'level_07', '07',
TextFileReader().read_text_file('level_07.txt'))
level_08: Level = Level(
'level_08', '08',
TextFileReader().read_text_file('level_08.txt'))
tutorial: Level = Level(
'tutorial', 'tutorial',
TextFileReader().read_text_file('tutorial.txt'))
level_01 = Helper.clean_level(level_01)
level_02 = Helper.clean_level(level_02)
level_03 = Helper.clean_level(level_03)
level_04 = Helper.clean_level(level_04)
level_05 = Helper.clean_level(level_05)
level_06 = Helper.clean_level(level_06)
level_07 = Helper.clean_level(level_07)
level_08 = Helper.clean_level(level_08)
database.store_level_prototype(level_01)
database.store_level_prototype(level_02)
database.store_level_prototype(level_03)
database.store_level_prototype(level_04)
database.store_level_prototype(level_05)
database.store_level_prototype(level_06)
database.store_level_prototype(level_07)
database.store_tutorial(tutorial)
level_01 = evolution.evolve('random_distribution', level_01)
level_02 = evolution.evolve('random_distribution', level_02)
level_03 = evolution.evolve('random_distribution', level_03)
level_04 = evolution.evolve('random_distribution', level_04)
level_05 = evolution.evolve('random_distribution', level_05)
level_06 = evolution.evolve('random_distribution', level_06)
level_07 = evolution.evolve('random_distribution', level_07)
level_08 = evolution.evolve('random_distribution', level_08)
database.store_initial_level(level_01)
database.store_initial_level(level_02)
database.store_initial_level(level_03)
database.store_initial_level(level_04)
database.store_initial_level(level_05)
database.store_initial_level(level_06)
database.store_initial_level(level_07)
database.store_initial_level(level_08)
from helper.helper import Helper
row = {'temperature_avg': 15.0, 'wetbulb_temperature': 17.0}
print(Helper.calculate_relative_humidity(row))
def setUp(self):
self.helper = Helper()
self.board = self.helper.add_board('Board Name')
def get_element_offset_width(self):
help_ = Helper(self._driver)
help_.wait_for_element(5, MainPage.SEARCH_FIELD)
arg = self._driver.find_element(*self.SEARCH_FIELD)
return self._driver.execute_script('return arguments[0].offsetWidth',
arg)
def after_all(context):
context.helper = Helper()
context.helper.close()