def tcp(ip: str, sender: int, receiver: int): """ :param ip: ip address to send tcp packets :param sender: sender port :param receiver: receiver port :return: void """ # i created a separate class to process files and split them accordingly. # for further information, you may refer to the packet.py file. file_name = "transfer_file_TCP.txt" p = Packet(file_name) packet_count = p.packet_count # opening the socket using try-with-resources method with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: # bind to the sender port to receive responses using that s.bind(('0.0.0.0', sender)) # get data split as packets using the packet.py methods packets = list(p.split_data()) # connect to the server using the ip and the port s.connect((ip, receiver)) # a header was implemented to send file name, timestamp and packet count. header = util.generate(file_name, time(), packet_count) # send the header before sending the data packets. s.send(header.encode()) # send data packets for i in range(packet_count): s.sendall(packets[i])
def test_generator(): for _test, browser in generate(__name__): yield _test, browser
test_pred['pred_latitude'] = test_pred['relative_latitude'] / pow( 10, 20) + X_test['Latitude_1'] split_dist = util.distance_evaluation(test_pred, y_test) splits_dist.append(split_dist) dist_df = X_test[main_bs_cols] dist = get_average_dist(splits_dist) dist_df['dist'] = dist pickle.dump(dist_df, open(params.e_errors_pkl, 'wb')) if __name__ == '__main__': train_flag = 0 if train_flag: data = util.generate(fillna_with_0=True) data = get_relative_pos(data) print(data[relaive_gps_cols].isnull()) data = util.drop(data, cols=['SignalLevel', 'AsuLevel', 'IMSI', 'MRTime']) train(data) plot(file=[params.c_errors_pkl, params.e_errors_pkl]) plot_median_errors_comparison(file=[ params.c_errors_pkl, params.d_errors_pkl, params.e_errors_pkl ]) else: plot(file=[ params.c_errors_pkl, params.d_errors_pkl, params.e_errors_pkl ]) plot_median_errors_comparison(file=[
def udp(ip: str, sender: int, receiver: int): """ :param ip: ip address to send tcp packets :param sender: sender port :param receiver: receiver port :return: """ # i created a separate class to process files and split them accordingly. # for further information, you may refer to the packet.py file. file_name = "transfer_file_UDP.txt" p = Packet(file_name) packet_count = p.packet_count # get data split as packets using the packet.py methods packets = list(p.split_data_for_udp()) # generate the header to send as the first package header = util.generate(file_name, time(), packet_count) header_sent = False # flag to check if header was sent packets_sent = [False] * packet_count # flag to check if packets sent last_sent = 0 # id of the last successfully sent package retry_count = 0 # retry counter # opening the socket using try-with-resources method with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: # i set the timeout as a second s.settimeout(1) # bind to the port s.bind(('', sender)) # try to send the header first while header_sent is False: s.sendto(header.encode(), (ip, receiver)) try: # as a response to the header, we need to check the ACK response, _ = s.recvfrom(2048) if response.decode() == header: # if we receive the header back, it means the header reached # set flag header_sent = True except Exception: # header was not retrieved, resend retry_count += 1 continue # if we have unsent packages, continue until they're complete while packets_sent.count(False) != 0: # generate the udp parcel to be sent using the first unsent packet parcel = p.generate_udp(*packets[last_sent]) # send parcel s.sendto(parcel, (ip, receiver)) try: # check if we get an ACK response, _ = s.recvfrom(2048) # read parcel nr and hash from the data parcel_nr, _, _, hashed = Packet.read_data_for_udp(parcel) # if the response is the correct hash, consider as ACK if response.decode() == hashed: # if this is the first unsent package, set it as sent # increment last_sent value by 1 # else, we have packets prior to this one, ignore this yet if packets_sent.index(False) == parcel_nr: packets_sent[parcel_nr] = True last_sent += 1 except Exception: # not received within time limit, retry retry_count += 1 continue # file transfer complete print(f"UDP Transmission Re-transferred Packets: {retry_count}")
import util if __name__ == '__main__': import argparse parser = argparse.ArgumentParser(description='GAN') parser.add_argument('--set', type=str, help="Accepted values: {mnist, cifar10}") parser.add_argument('--train', default=False, action='store_true', help='If set the training procedure is done') args = parser.parse_args() if args.set == 'mnist': import mnist as gan output = './resources/mnist/' elif args.set == 'cifar10': import cifar_10 as gan output = './resources/cifar_10/' else: print('Invalid data set') exit(1) checkpoint_prefix = output + 'ckpt' util.generate(output, gan, output, checkpoint_prefix, args.train)
import pickle import util # 50000 - Adversarial training samples # 10000 - Adversarial test samples adversarial_samples_training_set = util.generate_using_training_set(556) fname = 'adversarial_samples_training_set.pkl' pickle.dump(adversarial_samples_training_set, open(fname, 'wb')) adversarial_samples_test_set = util.generate(112) fname = 'adversarial_samples_test_set.pkl' pickle.dump(adversarial_samples_test_set, open(fname, 'wb'))
def udp(ip: str, port: int): """ :param ip: ip address to receive data from (not used) :param port: port to listen to :return: """ parcels = [] # list of data parcels file_name = "" # file name file = b'' # received data timestamp = [[0, 0]] # start and finish timestamps packet_count = 0 # total nr of packets header_received = False # flag to check if header was received packets_received = [False ] # list to check the first packet that did not arrive # try-with-resources for connection with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: # bind to the port s.bind(('', port)) # loop until all data is received while True: # read 2048 bytes of data every loop data, client_address = s.recvfrom(2048) # if data is valid, handle it, else wait until data arrives if data: # if header was not received, treat the first packet as header if not header_received: # try to decipher the data as header header_try = util.decipher(data) # if header can be parsed, then it is a valid header # else wait until header if header_try is not False: # try to split header, since it might be corrupted try: file_name, timestamp[0][ 0], packet_count, data = header_try # create the same header using the parsed data new_header = util.generate(file_name, timestamp[0][0], packet_count) # send it back as ACK s.sendto(new_header.encode(), client_address) # mark header received flag as True header_received = True # resize parcels list according to the packet count parcels = [b""] * packet_count # add first package receive time timestamp[0][1] = time() # resize timestamp list according to the packet count timestamp_append = [[0, 0]] * packet_count timestamp += timestamp_append # resize packets received list according to the packet count packets_received = [False] * packet_count except Exception: pass else: # header was received already, treat the data as parcel r = Packet.read_data_for_udp(data) # if the data is a valid parcel, use and ack it if r is not False: parcel_nr, timestamp_p, parcel, hashed = r # if the parcel nr is not registered, treat it as new if not packets_received[parcel_nr]: # save parcel, timestamp, and mark parcel as received parcels[parcel_nr] = parcel timestamp[parcel_nr + 1] = timestamp_p, time() packets_received[parcel_nr] = True # send ACK s.sendto(hashed.encode(), client_address) # if all packets were received, break from the loop if packets_received.count(False) == 0: break # merge parcels for parcel in parcels: file += parcel # write to file with open(file_name, "wb") as file_pointer: file_pointer.write(file) # calculate time differences time_differences = [t[1] - t[0] for t in timestamp] udp_average = (sum(time_differences) / len(time_differences)) * 1000 udp_total = (timestamp[-1][1] - timestamp[0][0]) * 1000 print(f"UDP Packets Average Transmission Time: {udp_average} ms") print(f"UDP Communication Total Transmission Time: {udp_total} ms")