def run_vns(self, solution: Solution, item_list: list, max_iterations: int, neighborhood_size: int, output_filename: str): print(f"ic| run_vns: Executing Variable Neighbourhood Search") counter = 0 output_file = FileWriter(file_name=output_filename) output_file.write_line(output_filename.replace('TEMP-', '')) output_file.write_line(str(solution.optimum)) output_file.write_line(f"{counter} {solution.value}") (value_list, weight_list) = General.parse_item_list_data(self.item_list) for i in range(max_iterations): initial_solution = solution k = 1 while k <= neighborhood_size: mask_list = General.get_mask_list(solution.n, k, climb=False) initial_solution = self.random_neighbor( solution, k, value_list, weight_list) if not initial_solution: continue best_neighbor = self.evaluate_neighborhood( initial_solution, mask_list, value_list, weight_list) if best_neighbor and best_neighbor.value > solution.value: counter += 1 solution = deepcopy(best_neighbor) #solution.print_solution() #ic(f"{counter} {solution.value}") output_file.write_line(f"{counter} {solution.value}") else: k += 1
class Controller: def __init__(self): self.file_writer = FileWriter() def get_file_contents(self, file_path): file = open(file_path, "r") contents = file.readlines() file.close() return contents # En base al archivo leido, instancia las tareas def fill_tasks(self, data): self.file_writer.write_content( "-------------CARGANDO DATASET-------------") tasks = [] for line in data: splitted_values = line.split(',') task_name = splitted_values[0] task_space = splitted_values[1] task_time = splitted_values[2] task = Task(name=task_name, space_requested=task_space, time_requested=task_time) tasks.append(task) self.file_writer.write_content(task.__str__()) return tasks
def run_local_search_improved(self): print( f"ic| run_local_search_improved: Executing Local Search with distance {self.distance}" ) counter = 0 output_file = FileWriter(file_name=self.output_filename) output_file.write_line(self.output_filename.replace('TEMP-', '')) output_file.write_line(str(self.solution.optimum)) output_file.write_line(f"{counter} {self.solution.value}") mask_list = General.get_mask_list(self.solution.n, self.distance, climb=True) (value_list, weight_list) = General.parse_item_list_data(self.item_list) while self.evaluate_neighborhood_improved(self.solution, mask_list, value_list, weight_list): counter += 1 #self.solution.print_solution() ic(f"{counter} {self.solution.value}") output_file.write_line(f"{counter} {self.solution.value}") # prevent looping indefinitely if counter >= 100: return
def test_write_file(self, input): # Arrange line1 = { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } line2 = { 'gender': 'M', 'age': '45', 'sales': '999', 'bmi': 'Underweight', 'salary': '725', 'birthday': '31/12/1971', 'valid': '1' } dict_valid = {'A001': line1, 'Q001': line2} open("Y", 'w').close() # Wipe the file for a fresh start # Act FileWriter.write_file(FileWriter, dict_valid, FileController) # Open the file it just saved with open("Y", 'rb') as file: result = file file.close() # Assert self.assertTrue(file)
def test_write_file_choosing_database_option(self): # Arrange user_input = ['Y', "D", "Y"] dict_valid = { 'A001': { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } } expected_string = "['A001', 'F,', '21,', '001,', 'Normal,', '12,'," \ " '01/01/1996,', '1']" expected_result = True # Act captured_output = io.StringIO() sys.stdout = captured_output with patch('builtins.input', side_effect=user_input): FileWriter.write_file(FileWriter, dict_valid, FileController) sys.stdout = sys.__stdout__ # Check if the printed output includes expected strings I'm looking for if expected_string in captured_output.getvalue(): result = True else: result = False # Assert self.assertTrue(result == expected_result)
def test_write_file_do_not_write(self, input): # Arrange line1 = { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } line2 = { 'gender': 'M', 'age': '45', 'sales': '999', 'bmi': 'Underweight', 'salary': '725', 'birthday': '31/12/1971', 'valid': '1' } dict_valid = {'A001': line1, 'Q001': line2} # Act FileWriter.write_file(FileWriter, dict_valid, FileController) # If a file called N exists, choosing no to saving the file failed try: open("N", 'rb') except FileNotFoundError: file_created = False else: file_created = True # Assert self.assertFalse(file_created)
def test_write_file_do_not_append_to_existing_file(self): # Arrange user_input = [ 'Y', 'F', "testdata\\file_already_exists.txt", "N", "Y", "F", "testdata\\new.txt", "Y" ] dict_valid = { 'A001': { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } } expected_result = ['This file already exists'] # Act with patch('builtins.input', side_effect=user_input): FileWriter.write_file(FileWriter, dict_valid, FileController) # Assert file = open('testdata\\file_already_exists.txt') result = [] for line in file: result.append(line) file.close() self.assertTrue(result == expected_result)
def test_write_file_new_file(self): # Arrange random_file_name = ''.join(random.sample(string.ascii_lowercase, 8)) random_file_name = "temp\\" + random_file_name + ".txt" user_input = ['Y', 'F', random_file_name] dict_valid = { 'A001': { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } } expected_result = [ '\n', 'A001,gender F,age 21,sales 001,bmi Normal,' 'salary 12,birthday 01/01/1996,valid 1,\n' ] # Act with patch('builtins.input', side_effect=user_input): FileWriter.write_file(FileWriter, dict_valid, FileController) # Assert file = open(random_file_name) result = [] for line in file: result.append(line) file.close() self.assertTrue(result == expected_result)
def test_write_file_invalid_input(self): # Arrange user_input = ['Z'] dict_valid = { 'A001': { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } } expected_output = "Invalid Input, please try again" # Act captured_output = io.StringIO() sys.stdout = captured_output with patch('builtins.input', side_effect=user_input): FileWriter.write_file(FileWriter, dict_valid, FileController) sys.stdout = sys.__stdout__ # Check if the printed output includes expected strings I'm looking for if expected_output in captured_output.getvalue(): result = True else: result = False # Assert self.assertTrue(result)
def __init__(self): super(Receiver, self).__init__() socket.setdefaulttimeout( 10 ) # Setarea timeout-ului de asteptare al socket-ului la 10 secunde self.__error_occurred = False # Variabila booleana care specifica daca s-a intamplat vreo eroare inainte de inceperea primrii pachetelor self.__is_socket_open = False # Variabila booleana care specifica daca socket-ul este deschis. self.__receiver_ip = None # IP-ul receiver-ului. self.__receiver_port = None # Portul receiver-ului self.__losing_packets_probability = 0 # Probabilitatea de pierdere a pachetelor self.__is_running = True # Variabila booleana care specifica daca receiver-ul ruleaza self.__SWR = { } # Fereastra protocolului sliding window de la nivelul receiver-ului self.__SWR_size = -1 # Dimensiunea ferestrei self.__last_packet_received = -1 # Ultimul pachet primit self.__total_nr_of_packets_to_receive = -1 # Numarul total de pachete care se vor primi self.__file_writer = FileWriter( "" ) # Obiect de tip FileWriter care gestioneaza fisierul in care se vor scrie datele primite. self.__ups = UnPackingSystem( self.DATA_PACKET_SIZE ) # Obiect de tip UnPackingSystem care desparte datele primite in campuri de biti. self.__nr_of_packets_recv = 0 # Numarul total de pachete primite self.__nr_of_packets_lost = 0 # Numarul total de pachete pierdute
def _main(args): file = Path(args.name) line_generator = LineGenerator(size=args.line_size) file_writer = FileWriter(file=file, records=args.records, line_generator=line_generator) file_writer.write(Bar("Processing", max=args.records))
def __init__(self, solution: Solution, item_list: list, distance: int, output_filename: str): self.solution = solution self.item_list = item_list self.distance = distance self.output_filename = output_filename # writing output variables self.output_file = FileWriter(file_name=self.output_filename)
def test_06(self): y = FileWriter() y.write_file("unit_test_file") try: with open(y.my_file) as f: pass except FileNotFoundError: print("ERROR - File not created")
def simulated_annealing(optimum_value: float, instance_dict: dict, output_filename: str): config = settings.EVALUATE_METHODS_SETTINGS max_iterations = config.get('sa', {}).get('max_iterations') distance = config.get('sa', {}).get('distance') initial_temperature = config.get('sa', {}).get('initial_temperature') best_solution = Solution( n=instance_dict.get('n'), capacity=instance_dict.get('capacity'), optimum=optimum_value ) best_solution.generate_starter_solution( item_list=instance_dict.get('item_list'), random_seed=RANDOM_SEED ) best_solution.print_solution() sa = SimulatedAnnealing( solution=deepcopy(best_solution), item_list=instance_dict.get('item_list'), distance=2, output_filename=f"{output_filename}_temp" ) current_solution = deepcopy(sa.solution) writer = FileWriter(file_name=f"{output_filename}_temp") for i in range(max_iterations): if i == 0: writer.write_line(output_filename.replace('TEMP-', '')) writer.write_line(str(current_solution.optimum)) writer.write_line(f"{i} {current_solution.value}") sa.solution = deepcopy(current_solution) # random neighbor test = sa.random_neighbor(distance=distance) if not test: print(f"ERROR ! Could not find a random neighbor") # if better set as best_solution if sa.solution.value > best_solution.value: best_solution = deepcopy(sa.solution) writer.write_line(f"{i} {best_solution.value}") # calculate diff diff = current_solution.value - sa.solution.value # calculate temp t = initial_temperature / float(i + 1) if diff < 0 or random() < exp(-diff / t): current_solution = deepcopy(sa.solution) print(f"ic| SA Optimum Solution") best_solution.print_solution(item_list=instance_dict.get('item_list')) return best_solution
def test_writer_writes_dates_to_file(self): writer = FileWriter(self.test_filename) expected_dates = self.article.get_dates() writer.write_to_file(self.article) with open(self.test_path, 'rt') as f: reader = csv.reader(f, delimiter=',') for row in reader: self.assertIn(expected_dates[0], row) self.assertIn(expected_dates[1], row)
def save_data(data, out_format, country): ''' Saves hotels list in file :param data: hotels list :param out_format: json, csv or excel :return: ''' writer = FileWriter(data, out_format, country) file = writer.output_file() print('All accommodations are saved.') print('You can find them in', file, 'file')
def calculate_results(self, file_writer: FileWriter): file_writer.write_content('Calculando resultados') file_writer.write_content( f'Tiempo de retorno de la tanda: {self.return_time}') file_writer.write_content( f'Indice de fragmentacion externa: {self.external_fragmentation_idx}' ) file_writer.write_content( 'Tiempos de retorno normalizados para cada tarea: ') for task in self.finished: file_writer.write_content( f' * {task.__str__()}: {task.normalized_return_time}')
def __init__(self, subject_id, run_type, transfer_learning, model_name): self.subject_id = subject_id self.run_type = run_type self.transfer_learning = transfer_learning self.model_name = model_name self.left_hand_total = 0 self.right_hand_total = 0 self.left_hand_correct = 0 self.right_hand_correct = 0 self.total_time_taken = 0 # int in seconds self.predictions = [] self.file_writer = FileWriter()
def save_data(data, out_format, country): """ Saves hotels list in file :param data: hotels list :param out_format: json, csv or excel :return: """ writer = FileWriter(data, out_format, country) file = writer.output_file() print("All accommodations are saved.") print("You can find them in", file, "file")
def get_partition(self, task: Task, memory, file_writer: FileWriter): file_writer.write_content('BestFit ejecutando seleccion de particion') possibles_partitions = [] for idx, partition in enumerate(memory.partitions): if (partition.task is None) and (partition.space_assigned >= task.space_requested): possibles_partitions.append(partition) try: part = possibles_partitions[0] except IndexError: part = None for partition in possibles_partitions[1:]: if partition.space_assigned < part.space_assigned: part = partition return part
def scrapeUSA(): USAMap = { "state": 0, "totalCases": 1, "newCases": 2, "totalDeaths": 3, "newDeaths": 4, "activeCases": 5, } scrapeRunner = ScrapeRunner( "https://www.worldometers.info/coronavirus/country/us", "usa_table_countries_today", USAMap) singleScrape = scrapeRunner.run() fileWriter = FileWriter(singleScrape, "usa") fileWriter.writeFile()
def scrapeWorld(): worldMap = { "state": 0, "totalCases": 1, "newCases": 2, "totalDeaths": 3, "newDeaths": 4, "totalRecovered": 5, "activeCases": 6, } scrapeRunner = ScrapeRunner("https://www.worldometers.info/coronavirus", "main_table_countries_today", worldMap) singleScrape = scrapeRunner.run() fileWriter = FileWriter(singleScrape, "world") fileWriter.writeFile()
class CodeGenerator: def __init__(self, setting, communicator): self.communicator = communicator self.communicator.debug("CodeGenerator loaded") self.communicator.debug("Object:" + str(setting)) self.setting = setting self.file_writer = FileWriter(setting, communicator) def generate(self): js_generator = JavaScriptGenerator(self.setting, self.file_writer, self.communicator) java_generator = JavaGenerator(self.setting, self.file_writer, self.communicator) js_generator.generate() java_generator.generate() self.file_writer.create_zip() generate = staticmethod(generate)
def test_save_pickle_file(self): # Arrange file_name = "testdata\\test_pickle_save.txt" data_to_save = "This is being saved to a file" # Act pickled = dumps(data_to_save) FileWriter.commit_pickle_save(file_name, pickled) # Pickle # Open the file it just saved with open(file_name, 'rb') as pickleFile: result = pickle.load(pickleFile) pickleFile.close() # Assert self.assertTrue(data_to_save == result)
def test_save_pickle_file_yes_saves_file(self, input): # Arrange data_to_save = "Something to pickle" pickled = dumps(data_to_save) # Act FileWriter.save_pickle_file(FileWriter, pickled) # Open the file it just saved, called Y because I can only submit # the same input to every request for input with open("Y", 'rb') as pickleFile: result = pickle.load(pickleFile) pickleFile.close() # Assert self.assertTrue(data_to_save == result)
def run_local_search(self): print( f"ic| run_local_search: Executing Local Search with distance {self.distance}" ) counter = 0 output_file = FileWriter(file_name=self.output_filename) output_file.write_line(self.output_filename.replace('TEMP-', '')) output_file.write_line(str(self.solution.optimum)) output_file.write_line(f"{counter} {self.solution.value}") while self.evaluate_neighborhood(self.solution, self.item_list, self.distance): counter += 1 #self.solution.print_solution() #ic(f"{counter} {self.solution.value}") output_file.write_line(f"{counter} {self.solution.value}")
def run(journal, num_articles): # Setup output file, get input parameters, and use brief run if testing writer = FileWriter(pars.filename) journal = journal # journal name num_articles = num_articles # number of articles to use from each issue num_volumes = 18 # 18 volumes per year issue = 1 # sample issue for each volume # if len(sys.argv) > 1: # print "Testing....." # num_articles = 10 # num_volumes = 1 # Sample papers accepted in previous year date = html.detect_start_volume() start_volume = date[0] acceptance_year = date[1] volumes = range(start_volume-num_volumes+1, start_volume+1) # for volume in reversed(volumes): # # Go to volume/issue contents page, and extract URLs of articles # articles = html.build_urls(journal, volume, issue) # for num in range(1, num_articles+1): # # For first 'num_articles' in this volume/issue, try to extract date string from article webpage # url = articles[num] # try: # date_string = html.get_date_div(url) # except: # print "Some error occurred (URL '",url,"' not available?). Skipping." # break # article = Article(date_string) # if article.get_year() == acceptance_year: # writer.write_to_file(article) writer.close_file()
def test_save_pickle_file_no_does_not_save_file(self, input): # Arrange data_to_save = "Something to pickle" pickled = dumps(data_to_save) # Act FileWriter.save_pickle_file(FileWriter, pickled) # If a file called N exists, choosing no to saving the file failed try: open("N", 'rb') except FileNotFoundError: file_created = False else: file_created = True # Assert self.assertFalse(file_created)
def test_write_to_database_with_valid_data(self): # Arrange user_input = ['Y'] line1 = { 'gender': 'F', 'age': '21', 'sales': '001', 'bmi': 'Normal', 'salary': '12', 'birthday': '01/01/1996', 'valid': '1' } line2 = { 'gender': 'M', 'age': '45', 'sales': '999', 'bmi': 'Underweight', 'salary': '725', 'birthday': '31/12/1971', 'valid': '1' } data_to_test = {'A001': line1, 'T991': line2} expected_string_1 = "['A001', 'F,', '21,', '001,', 'Normal,', '12,'," \ " '01/01/1996,', '1']" expected_string_2 = "['T991', 'M,', '45,', '999,', 'Underweight,'," \ " '725,', '31/12/1971,', '1']" expected_result = True # Act captured_output = io.StringIO() sys.stdout = captured_output with patch('builtins.input', side_effect=user_input): FileWriter.write_to_database(FileWriter, data_to_test) sys.stdout = sys.__stdout__ # Check if the printed output includes expected strings I'm looking for if expected_string_1 in captured_output.getvalue()\ and expected_string_2 in captured_output.getvalue(): result = True else: result = False # Assert self.assertTrue(result == expected_result)
def call_file(self, switch, separator=','): valid_dict = None file_name = input("Please enter the filename to read data from >>> ") split_filename = file_name.split(".") file_extension = split_filename[-1] wb = None file = None if file_extension == "xls" or file_extension == "xlsx": try: wb = self.file_reader.fetch_workbook_file(file_name) except FileNotFoundError: print(Err.get_error_message(201)) self.call_file(self, switch) except OSError: print(Err.get_error_message(103)) self.call_file(self, switch) if wb is not None: data_to_save = self.file_reader.fetch_workbook_contents( wb, switch) FileWriter.write_file(FileWriter, data_to_save, self) elif file_extension == "txt" or file_extension == "csv": try: open(file_name, 'r') except FileNotFoundError: print(Err.get_error_message(201)) self.call_file(self, switch) except OSError: print(Err.get_error_message(103)) self.call_file(self, switch) else: file = self.file_reader.fetch_text_file(file_name) if file is not None: valid_dict = self.file_reader.fetch_text_contents( file, switch, separator) else: print(Err.get_error_message(204)) if valid_dict: FileWriter.write_file(FileWriter, valid_dict, self)