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()