def evaluate_method(**kwargs): start = time.time() solution: Solution = kwargs['method_function']( optimum_value=kwargs['optimum_value'], instance_dict=kwargs['instance_dict'], output_filename=kwargs['output_filename']) end = time.time() solution_dict = solution.to_dict() accuracy = (solution_dict.get('value') / kwargs['optimum_value']) * 100 is_valid_str = "VALID" if solution.is_valid(item_list=kwargs.get( 'instance_dict', {}).get('item_list')) else "INVALID" config = kwargs.get('config') del config['enable'] result_file = FileWriter(file_name="evaluation_result", mode="append") result_file.write_line( f"----------------------------------------------------------------------------------------------------------" ) result_file.write_line(f"| Method: {kwargs['output_filename']}") for parameter in config: result_file.write_line(f"| {parameter}: {config[parameter]}") result_file.write_line(f"| {json.dumps(solution_dict)}") result_file.write_line( f"| {is_valid_str} SOLUTION | Execution time: {end - start} | Accuracy: {accuracy}" ) result_file.write_line( f"----------------------------------------------------------------------------------------------------------" ) result_file.close_file()
def run(journal, num_articles): print "Running publication-dates version 1.1\n" # Setup output file, set parameters, and use brief run if testing writer = FileWriter(journal) num_volumes = 18 # 18 volumes per year issue = 1 # sample issue for each volume if len(sys.argv) > 1: print "Testing....." num_articles = 3 num_volumes = 1 # Sample papers accepted in previous year date = html.detect_start_volume() start_volume = date[0] acceptance_year = date[1] counter = 0 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) counter += 1 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() return counter
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()
class Receiver(QObject): log_signal = pyqtSignal( str ) # Obiect de tip pyqtSignal menit sa transmita mesaje catre log-ul din interfata grafica. finish_signal = pyqtSignal( ) # Obiect de tip pyqtSignal menit sa transmita un semnal in momentul in care se termina de primit pachete. set_total_nr_of_packets_signal = pyqtSignal( int ) # Obiect de tip pyqtSignal menit sa transmita un semnal in momentul in care se cunoaste numarul total de pachete ce urmeaza sa se primeasca. loading_bar_signal = pyqtSignal( int ) # Obiect de tip pyqtSignal menit sa transmita un semnal in care se primeste un pachet. INIT_PACKET_SIZE = 64 # Dimensiunea pachetului de initializare. Este stabilita ca fiind 64 de octeti. DATA_PACKET_SIZE = INIT_PACKET_SIZE # Dimensiunea pachetului de date. Initial nu se cunoaste dimensiunea pachetului ce va fi transmis. Se intializeaza cu 64 octeti. CHECK_PACKET_SIZE = 4 # Dimensiunea pachetului de confirmare ACK_PACKET_SIZE = 4 # Dimensiunea pachetului de acknowledge PACKET_TYPE_SIZE = 1 # Dimensiunea campului tipului de pachet primit PACKET_COUNTER_SIZE = 3 # Dimensiunea campului numarului de secventa din pachet DATA_SIZE = DATA_PACKET_SIZE - PACKET_COUNTER_SIZE - PACKET_TYPE_SIZE # Dimensiunea campului de date din pachete de date PACKET_HEADER_SIZE = PACKET_TYPE_SIZE + PACKET_COUNTER_SIZE # Dimensiunea header-ului pachetului FIRST_PACKET = 0 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 ''' Functie membru pentru crearea unui socket ''' def create_socket(self, af_type, sock_type): random.seed(datetime.now()) check_socket(af_type, sock_type) self.__s = socket.socket(af_type_dic.get(af_type), sock_type_dic.get(sock_type)) # IPV4, UDP try: self.__s.bind((self.__receiver_ip, self.__receiver_port)) self.__is_socket_open = True except OSError as os: self.log_signal.emit( "Nu se poate face bind pe adresa precizata. Adresa indisponibila." ) self.__error_occurred = True return self.log_signal.emit("S-a facut bind pe adresa: " + str(self.__receiver_ip) + " si portul: " + str(self.__receiver_port)) ''' Functie membru pentru reinitializarea membrilor receiver-ului dupa terminarea acestuia ''' def reset_receiver(self): self.DATA_PACKET_SIZE = self.INIT_PACKET_SIZE self.DATA_SIZE = -1 self.__is_running = True self.__SWR.clear() self.__SWR_size = -1 self.__last_packet_received = -1 self.__total_nr_of_packets_to_receive = -1 self.__nr_of_packets_lost = 0 self.__nr_of_packets_recv = 0 ''' Functie membru care implementeaza functionalitatea receiver-ului ''' def start_receiver(self): if self.__error_occurred == True: # Daca s-a intamplat vreo eroare la crearea socket-ului, procedura de gestionare a pachetelor nu mai are loc. self.__error_occurred = False return data_packet = SWPacket(self.DATA_PACKET_SIZE, self.DATA_SIZE, self.PACKET_HEADER_SIZE, packet_type=PacketType.INIT) ack_packet = SWPacket(self.ACK_PACKET_SIZE, 0, self.PACKET_HEADER_SIZE, packet_type=PacketType.ACK) name = "new_" self.log_signal.emit("Probabilitatea de pierdere a pachetelor este: " + str(self.__losing_packets_probability)) self.log_signal.emit("Se asteapta pachete...") ########################### Incepere gestionare pachete ############################### while self.__is_running: try: data_readed, address = self.__s.recvfrom( self.DATA_PACKET_SIZE) # Primire pachete except socket.timeout: self.log_signal.emit("Timeout-ul de " + str(socket.getdefaulttimeout()) + " secunde al receiver-ului s-a terminat.") self.__is_running = False continue except OSError as os: if "[WinError 10040]" in str(os): self.log_signal.emit( "[WinError 10040] S-a primit un pachet mai mare decat dimensiunea buffer-ului de receptie." ) self.log_signal.emit( "Se asteapta pachete in continuare...") continue self.__nr_of_packets_recv += 1 ########################### Testarea conexiunii ############################### if int.from_bytes( data_readed[:self.PACKET_HEADER_SIZE - self.PACKET_COUNTER_SIZE], "big" ) == PacketType.CHECK: # Retrimitere pachete de conexiune self.log_signal.emit( "Am primit mesaj de testare a conexiunii de la adresa: " + str(address)) self.__s.sendto(data_readed, address) continue ########################### Aruncare pachete ############################### data_packet.create_packet(data_readed) type, nr_packet, data = self.__ups.unpack(data_packet) if is_packet_lost(self.__losing_packets_probability) or ( self.__last_packet_received == -1 and nr_packet != self.FIRST_PACKET and nr_packet != 0xFFFFFF ): # Verificam daca vom pierde intentionat acest pachet self.log_signal.emit("Am aruncat pachetul cu numarul: " + str(nr_packet)) self.__nr_of_packets_lost += 1 continue ########################### Trimitere ACK ############################### self.log_signal.emit("Am primit pachetul cu numarul: " + str(nr_packet)) ack_packet.set_packet_number( nr_packet) # Trimitem ACK pentru fiecare pachet primit self.__s.sendto(ack_packet.get_header(), address) ########################### Mecanism sliding window ############################### if nr_packet == self.__last_packet_received + 1: # Gestionarea pachetului urmator if type == PacketType.DATA: if self.__file_writer.is_open() == True: self.__file_writer.write_in_file(data) else: self.log_signal.emit( "S-a incercat scrierea intr-un fisier inchis.") elif type == PacketType.INIT: if nr_packet == self.FIRST_PACKET: start = time.time() self.__total_nr_of_packets_to_receive = int.from_bytes( self.__ups.get_byte_x_to_y(1, 3, data), "big") self.set_total_nr_of_packets_signal.emit( self.__total_nr_of_packets_to_receive) self.DATA_PACKET_SIZE = int.from_bytes( self.__ups.get_byte_x_to_y(4, 5, data), "big") self.DATA_SIZE = self.DATA_PACKET_SIZE - self.PACKET_HEADER_SIZE data_packet = SWPacket(self.DATA_PACKET_SIZE, self.DATA_SIZE, self.PACKET_HEADER_SIZE, packet_type=PacketType.DATA) self.log_signal.emit( "Se vor primii " + str(self.__total_nr_of_packets_to_receive) + " pachete a cate " + str(self.DATA_PACKET_SIZE) + " octeti fiecare.") self.__ups.set_packet_size(self.DATA_PACKET_SIZE) self.__SWR_size = int.from_bytes( self.__ups.get_byte_x_to_y(6, 6, data), "big") self.log_signal.emit("Dimensiunea ferestrei este: " + str(self.__SWR_size)) name += self.__ups.get_byte_x_to_y( 7, self.DATA_SIZE, data).decode("ascii") self.__file_writer.set_file_name(name) self.__file_writer.open_file() self.log_signal.emit( "Am deschis fisierul cu numele: " + name) else: self.__last_packet_received += 1 self.log_signal.emit("Ultimul pachet a fost: " + str(self.__last_packet_received)) self.loading_bar_signal.emit(nr_packet + 1) break self.__last_packet_received += 1 while self.__last_packet_received + 1 in self.__SWR.keys( ): # Gestionarea pachetului care ocupa primul loc din fereastra (type, data) = self.__SWR[self.__last_packet_received + 1] self.__SWR.pop(self.__last_packet_received + 1) if type == PacketType.DATA: if self.__file_writer.is_open() == True: self.__file_writer.write_in_file(data) else: self.log_signal.emit( "S-a incercat scrierea intr-un fisier inchis.") else: self.__last_packet_received += 1 self.__is_running = False self.log_signal.emit("Ultimul pachet a fost: " + str(self.__last_packet_received)) break self.__last_packet_received += 1 elif nr_packet > self.__last_packet_received + 1: # Gestionarea pachetului primit care nu ar ocupa primul loc din fereastra if nr_packet == 0xFFFFFF: self.__is_running = False continue self.__SWR[nr_packet] = (type, data) if len(self.__SWR) > self.__SWR_size: self.log_signal.emit( "Eroare! S-a depasit dimensiunea ferestrei. Se opreste receptia pachetelor." ) self.__is_running = False continue self.loading_bar_signal.emit(self.__last_packet_received + 1) # Update loading bar ########################### Terminare executie receiver ############################### if self.__total_nr_of_packets_to_receive == self.__last_packet_received + 1: end = time.time() self.log_signal.emit("Done!") self.log_signal.emit("Timp de executie: " + str(end - start)) self.log_signal.emit("Procentul de pachete pierdute este: " + str(100 * float("{:.4f}".format( float(self.__nr_of_packets_lost / self.__nr_of_packets_recv), 2))) + "%") else: self.log_signal.emit( "Program inchis de utilizator sau sender-ul s-a oprit.") if self.__file_writer.is_open(): # Inchidem fisier self.__file_writer.close_file() self.log_signal.emit("Fisierul s-a inchis.") while self.__total_nr_of_packets_to_receive == self.__last_packet_received + 1: # Trimitem ACK-uri pierdute self.log_signal.emit( "Se asteapta pachete pentru care s-a pierdut confirmarea.") self.log_signal.emit("Receiver-ul se opreste automat in " + str(socket.getdefaulttimeout()) + " secunde daca nu se primesc pachete.") try: data_readed, address = self.__s.recvfrom(self.DATA_PACKET_SIZE) except socket.timeout: self.log_signal.emit( "Timeout-ul de " + str(socket.getdefaulttimeout()) + " secunde al receiver-ului in partea de ACK s-a terminat.") break data_packet.create_packet(data_readed) type, nr_packet, data = self.__ups.unpack(data_packet) if nr_packet == 0xFFFFFF: self.log_signal.emit("Program finalizat cu succes.") break elif nr_packet > self.__last_packet_received - self.__SWR_size: # Verificam ca pachete primite sa ocupe ultima fereastra self.log_signal.emit( "Am primit ACK pentru pachetul cu numarul: " + str(nr_packet)) ack_packet.set_packet_number(nr_packet) self.__s.sendto(ack_packet.get_header(), address) self.close_connection() self.finish_signal.emit() # Resetam butoanele interfetei self.reset_receiver() def set_ip_address(self, ip_address): self.__receiver_ip = ip_address def set_port(self, port): self.__receiver_port = port def set_probability(self, probability): self.__losing_packets_probability = probability def get_ip_address(self): return self.__receiver_ip def get_port(self): return self.__receiver_port def set_is_running(self, bool_val): self.__is_running = bool_val def get_socket(self): return self.__s def close_connection(self): self.log_signal.emit("Socket-ul s-a inchis.") self.__is_socket_open = False try: self.__s.close() except AttributeError as ae: self.log_signal.emit("Nu se poate inchide un socket ne declarat.") def is_socket_open(self): return self.__is_socket_open