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)
