def handle_arrival_msg(self): msg = self.network_layer.recv() msg_data = util.extract_data(msg) if (msg_data.is_corrupt): if (self.is_receiver): if self.expected_sequence_number == 0: util.log("Packet received is corrupted. " + self.NO_PREV_ACK_MSG) return self.network_layer.send(self.receiver_last_ack) util.log("Received corrupted data. Resending ACK: " + util.pkt_to_string( util.extract_data(self.receiver_last_ack))) return # Si es un mensaje ACK message, se asume que es para el emisor. if msg_data.msg_type == config.MSG_TYPE_ACK: self.sender_lock.acquire() self.sender_base = msg_data.seq_num + 1 if (self.sender_base == self.next_sequence_number): util.log( "Received ACK with seq # matching the end of the window: " + util.pkt_to_string(msg_data) + ". Cancelling timer.") self.timer.cancel() else: util.log( "Received ACK: " + util.pkt_to_string(msg_data) + ". There are messages in-flight. Restarting the timer.") if self.timer.is_alive(): self.timer.cancel() self.set_timer() self.timer.start() self.sender_lock.release() # Si es un mensaje DATA,se asume que es para el receptor else: assert msg_data.msg_type == config.MSG_TYPE_DATA util.log("Received DATA: " + util.pkt_to_string(msg_data)) if msg_data.seq_num == self.expected_sequence_number: self.msg_handler(msg_data.payload) ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, self.expected_sequence_number) self.network_layer.send(ack_pkt) self.receiver_last_ack = ack_pkt self.expected_sequence_number += 1 util.log("Sent ACK: " + util.pkt_to_string(util.extract_data(ack_pkt))) else: if self.expected_sequence_number == 0: util.log("Packet received is out of order. " + self.NO_PREV_ACK_MSG) return util.log("DATA message had unexpected sequence #" + str(int(msg_data.seq_num)) + ". Resending ACK message with sequence # " + str(int(self.expected_sequence_number - 1)) + ".") self.network_layer.send(self.receiver_last_ack) return
def kde1(datasets, axis, bandwidth=None, npoints=1001, xmin=None, xmax=None, xrange_=None, axes=None): """ """ # Extract data data = util.extract_data(datasets, axis) titles = util.extract_title(datasets) xmin, xmax = util.set_limits(data, xmin, xmax, xrange_, axis) if bandwidth is None: bandwidth = util.default_bandwidth(axis, npoints, xmin, xmax) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis, ) xgrid = np.linspace(xmin, xmax, npoints) for (d, t) in zip(data, titles): den = kde.hat_linear(d, bandwidth, xmin, xmax, npoints) ax.plot(xgrid, den, label=t) ax.set_yscale(util.default_yscale(axis)) ax.set_xlabel(axis) ax.set_ylabel('Density Estimate') if len(data) > 1: ax.legend() else: ax.set_title(titles[0]) return fig
def kde1(datasets, axis, bandwidth = None, npoints = 1001, xmin = None, xmax = None, xrange_ = None, axes = None): """ """ # Extract data data = util.extract_data(datasets, axis) titles = util.extract_title(datasets) xmin, xmax = util.set_limits(data, xmin, xmax, xrange_, axis) if bandwidth is None: bandwidth = util.default_bandwidth(axis, npoints, xmin, xmax) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis, ) xgrid = np.linspace(xmin, xmax, npoints) for (d, t) in zip(data, titles): den = kde.hat_linear(d, bandwidth, xmin, xmax, npoints) ax.plot(xgrid, den, label = t) ax.set_yscale(util.default_yscale(axis)) ax.set_xlabel(axis) ax.set_ylabel('Density Estimate') if len(data) > 1: ax.legend() else: ax.set_title(titles[0]) return fig
def hist1(datasets, axis, bins=None, xmin=None, xmax=None, xrange_=None, axes=None): """One dimensional histograms. """ # Extract data data = util.extract_data(datasets, axis) titles = util.extract_title(datasets) xmin, xmax = util.set_limits(data, xmin, xmax, xrange_, axis) if bins is None: bins = util.bin_default(axis, xmin, xmax) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis, ) # Plotting preferences alpha = util.alpha(len(data)) # We do not use the Matplotlib API for histograms because we want to have transparent plots # Following example: http://matplotlib.org/examples/api/histogram_path_demo.html max_value = float('-inf') for (d, t) in zip(data, titles): (hist, bin_edges) = np.histogram(d, bins=bins, range=(xmin, xmax)) left = np.array(bin_edges[:-1]) right = np.array(bin_edges[1:]) # FIXES a bug in MPLD3 0.3 regarding NaNs in coordinates bottom = 1e-6 * np.ones(len(left)) top = bottom + hist XY = np.array([[left, left, right, right], [bottom, top, top, bottom]]).T barpath = matplotlib.path.Path.make_compound_path_from_polys(XY) # serves to get the current color base_line, = ax.plot(hist, alpha=0) patch = matplotlib.patches.PathPatch(barpath, facecolor=base_line.get_color(), edgecolor=base_line.get_color(), alpha=alpha) # Clear the unneeded line base_line.remove() patch.set_label(t) ax.add_patch(patch) max_value = max(max_value, top.max()) ax.set_xlim(xmin, xmax) ax.set_ylim(1, max_value) ax.set_xlabel(axis) ax.set_yscale(util.default_yscale(axis)) if len(data) > 1: ax.legend() else: ax.set_title(titles[0]) return fig
def read_and_dump_data(): tree = ET.parse(SETTINGS.file_name) message_nodes, email_address_nodes, person_nodes, edges = util.extract_data(tree) #writing parsed objects to the file pickle.dump(message_nodes, open(SETTINGS.message_object_file, "wb")) pickle.dump(email_address_nodes, open(SETTINGS.email_object_file, "wb")) pickle.dump(person_nodes, open(SETTINGS.person_object_file, "wb")) pickle.dump(edges, open(SETTINGS.edge_object_file, "wb"))
def handle_arrival_msg(self): msg = self.network_layer.recv() msg_data = util.extract_data(msg) if (msg_data.is_corrupt): if (self.is_receiver): if not self.last_pkt_sent_data: return util.log("Received corrupt data. Resending: " + util.pkt_to_string(self.last_pkt_sent_data)) self.network_layer.send(self.last_pkt_sent) return # If ACK message, assume its for sender if msg_data.msg_type == config.MSG_TYPE_ACK: if self.sender_state == config.WAIT_FOR_ACK_MSG and msg_data.seq_num == self.sequence_number: util.log("Received ACK with expected seq #. " + util.pkt_to_string(msg_data)) self.sender_lock.acquire() self.timer.cancel() self.sequence_number = not (self.sequence_number ) # flip the sequence number self.sender_state = config.WAIT_FOR_APP_DATA self.sender_lock.release() # If DATA message, assume its for receiver else: assert msg_data.msg_type == config.MSG_TYPE_DATA util.log("Received DATA: " + util.pkt_to_string(msg_data)) if msg_data.seq_num == self.sequence_number: self.msg_handler(msg_data.payload) ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, self.sequence_number) self.network_layer.send(ack_pkt) self.last_pkt_sent = ack_pkt self.last_pkt_sent_data = util.extract_data(ack_pkt) self.sequence_number = not (self.sequence_number ) # flip the sequence number util.log("Sent ACK: " + util.pkt_to_string(self.last_pkt_sent_data)) else: util.log( "Duplicate DATA message. Resending ACK message with sequence # " + str(int(self.last_pkt_sent_data.seq_num)) + ".") self.network_layer.send(self.last_pkt_sent) return
def read_and_dump_data(): tree = ET.parse(SETTINGS.file_name) message_nodes, email_address_nodes, person_nodes, edges = util.extract_data( tree) #writing parsed objects to the file pickle.dump(message_nodes, open(SETTINGS.message_object_file, "wb")) pickle.dump(email_address_nodes, open(SETTINGS.email_object_file, "wb")) pickle.dump(person_nodes, open(SETTINGS.person_object_file, "wb")) pickle.dump(edges, open(SETTINGS.edge_object_file, "wb"))
def _send_helper(self, msg): self.sender_lock.acquire() packet = util.make_packet(msg, config.MSG_TYPE_DATA, self.next_sequence_number) packet_data = util.extract_data(packet) self.window[self.next_sequence_number % config.WINDOW_SIZE] = packet util.log("Sending data: " + util.pkt_to_string(packet_data)) w = SingleWindow(self.next_sequence_number, self.network_layer, packet, self.sender_lock).start() self.windows[self.next_sequence_number] = w self.next_sequence_number += 1 self.sender_lock.release() return
def _timeout(self): util.log("Timeout! Resending all packets in window. Resending packets with seq #s " + str(self.sender_base) + "-" + str(self.next_sequence_number-1) +".") self.sender_lock.acquire() if self.timer.is_alive(): self.timer.cancel() self.set_timer() for i in range(self.sender_base,self.next_sequence_number): pkt = self.window[(i%config.WINDOW_SIZE)] self.network_layer.send(pkt) util.log("Resending packet: " + util.pkt_to_string(util.extract_data(pkt))) self.timer.start() self.sender_lock.release() return
def _timeout(self, seq_num): util.log(f"Timeout! Resending packet {seq_num}") self.sender_lock.acquire() packet_offset_index = (seq_num - self.sender_base) % config.WINDOW_SIZE self.timer_list[packet_offset_index].cancel() self.timer_list[packet_offset_index] = self.set_timer(seq_num) pkt = self.sender_buffer[packet_offset_index] self.network_layer.send(pkt) util.log("Resending packet: " + util.pkt_to_string(util.extract_data(pkt))) self.timer_list[packet_offset_index].start() self.sender_lock.release() return
def hist1(datasets, axis, bins = None, xmin = None, xmax = None, xrange_ = None, axes = None): """One dimensional histograms. """ # Extract data data = util.extract_data(datasets, axis) titles = util.extract_title(datasets) xmin, xmax = util.set_limits(data, xmin, xmax, xrange_, axis) if bins is None: bins = util.bin_default(axis, xmin, xmax) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis, ) # Plotting preferences alpha = util.alpha(len(data)) # We do not use the Matplotlib API for histograms because we want to have transparent plots # Following example: http://matplotlib.org/examples/api/histogram_path_demo.html max_value = float('-inf') for (d, t) in zip(data, titles ): (hist, bin_edges) = np.histogram(d, bins = bins, range = (xmin, xmax)) left = np.array(bin_edges[:-1]) right = np.array(bin_edges[1:]) # FIXES a bug in MPLD3 0.3 regarding NaNs in coordinates bottom = 1e-6*np.ones(len(left)) top = bottom + hist XY = np.array([[left,left,right,right], [bottom, top, top, bottom]]).T barpath = matplotlib.path.Path.make_compound_path_from_polys(XY) # serves to get the current color base_line, = ax.plot(hist, alpha = 0) patch = matplotlib.patches.PathPatch(barpath, facecolor = base_line.get_color(), edgecolor = base_line.get_color(), alpha = alpha) # Clear the unneeded line base_line.remove() patch.set_label(t) ax.add_patch(patch) max_value = max(max_value, top.max()) ax.set_xlim(xmin, xmax) ax.set_ylim(1, max_value ) ax.set_xlabel(axis) ax.set_yscale(util.default_yscale(axis)) if len(data) > 1: ax.legend() else: ax.set_title(titles[0]) return fig
def _send_helper(self, msg): self.sender_lock.acquire() packet = util.make_packet(msg, config.MSG_TYPE_DATA, self.next_sequence_number) packet_data = util.extract_data(packet) self.window[self.next_sequence_number%config.WINDOW_SIZE] = packet util.log("Sending data: " + util.pkt_to_string(packet_data)) self.network_layer.send(packet) if self.sender_base == self.next_sequence_number: if self.timer.is_alive(): self.timer.cancel() self.set_timer() self.timer.start() self.next_sequence_number += 1 self.sender_lock.release() return
def send_helper(self ,msg): while self.sender_state == config.WAITING_FOR_ACK_MESSAGE: # sleep here so less busy waiting. time.sleep(0.01) packet = util.make_packet(msg, config.MESSAGE_TYPE_DATA, self.sequence_number) packet_data = util.extract_data(packet) self.sender_lock.acquire() util.log("Sending data: " + util.packet_to_string(packet_data)) self.network_layer.send(packet) self.last_pkt_sent = packet self.last_packet_sent_data = packet_data self.sender_state = config.WAITING_FOR_ACK_MESSAGE self.set_timer() self.timer.start() self.sender_lock.release() return
def handle_arrival_msg(self): NO_PREV_ACK_MSG = "Don't have previous ACK to send, will wait for server to timeout." msg = self.network_layer.recv() msg_data = util.extract_data(msg) # Ignore corrupt, let it lapse into timeout, no time to do hahahahahaha # if msg_data.is_corrupt: # if self.is_receiver: # if self.expected_sequence_number == 0: # util.log("Packet received is corrupted. " + NO_PREV_ACK_MSG) # return # self.network_layer.send(self.receiver_last_ack) # util.log("Received corrupted data. Resending ACK: " # + util.pkt_to_string(util.extract_data(self.receiver_last_ack))) # return # If ACK message, assume its for sender if msg_data.msg_type == config.MSG_TYPE_ACK: self.sender_lock.acquire() util.log("Received ACK: " + util.pkt_to_string(msg_data) + ". Mark as acked") self.windows[msg_data.seq_num].acked = True self.windows.pop(msg_data.seq_num, None) if self.sender_base == msg_data.seq_num: self.sender_base = min(self.windows.keys()) self.sender_lock.release() # If DATA message, assume its for receiver else: assert msg_data.msg_type == config.MSG_TYPE_DATA util.log("Received DATA: " + util.pkt_to_string(msg_data)) # can receive messages out of order # if msg_data.seq_num == self.expected_sequence_number: # self.msg_handler(msg_data.payload) # ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, self.expected_sequence_number) # self.network_layer.send(ack_pkt) # self.receiver_last_ack = ack_pkt # self.expected_sequence_number += 1 # util.log("Sent ACK: " + util.pkt_to_string(util.extract_data(ack_pkt))) # else: # if self.expected_sequence_number == 0: # util.log("Packet received is out of order. " + NO_PREV_ACK_MSG) # return # util.log("DATA message had unexpected sequence #" # + str(int(msg_data.seq_num)) + ". Resending ACK message with sequence # " # + str(int(self.expected_sequence_number - 1)) + ".") # self.network_layer.send(self.receiver_last_ack) return
def _send_helper(self, msg): self.sender_lock.acquire() packet = util.make_packet( msg, config.MSG_TYPE_DATA, self.next_sequence_number ) # LLamo a la funcion para armar el paquete en util packet_data = util.extract_data( packet ) # LLamo a la funcion para extraer los datos y recibir el RDTPacket self.window[self.next_sequence_number % config.WINDOW_SIZE] = packet util.log("Sending data: " + util.pkt_to_string(packet_data)) self.network_layer.send( packet) #Llama a la funcion para enviar el paquete if self.sender_base == self.next_sequence_number: if self.timer.is_alive(): self.timer.cancel() self.set_timer() self.timer.start() self.next_sequence_number += 1 self.sender_lock.release() return
def _timeout(self, *args): packet = args[0] seq_num = args[1] self.sender_lock.acquire() packet_data = util.extract_data(packet) util.log("Timeout! Resending packet: " + util.pkt_to_string(packet_data)) window_index = ( seq_num - self.sender_base ) % config.WINDOW_SIZE # window_index is the index to the acked_flag_list and timer_list for a particular packet current_timer = self.timer_list[window_index] # cancel the old thread if current_timer: current_timer.cancel() self.set_timer(packet, packet_data.seq_num) # set up a new timer thread self.network_layer.send(packet) self.timer_list[window_index].start() self.sender_lock.release() return
def _send_helper(self, msg): self.sender_lock.acquire() packet = util.make_packet(msg, config.MSG_TYPE_DATA, self.next_sequence_number) packet_data = util.extract_data(packet) util.log("Sending data: " + util.pkt_to_string(packet_data)) self.network_layer.send(packet) if self.next_sequence_number < self.sender_base + config.WINDOW_SIZE: packet_offset_index = (self.next_sequence_number - self.sender_base) % config.WINDOW_SIZE print(packet_offset_index) self.sender_buffer[packet_offset_index] = packet self.ack_list[packet_offset_index] = False self.timer_list[packet_offset_index] = self.set_timer( self.next_sequence_number) self.timer_list[packet_offset_index].start() self.next_sequence_number += 1 else: pass self.sender_lock.release() return
def _send_helper(self, msg): self.sender_lock.acquire() packet = util.make_packet(msg, config.MSG_TYPE_DATA, self.next_sequence_number) packet_data = util.extract_data(packet) window_index = ( self.next_sequence_number - self.sender_base ) % config.WINDOW_SIZE # window_index is the index to the acked_flag_list and timer_list for a particular packet util.log("Sending data: " + util.pkt_to_string(packet_data)) self.network_layer.send(packet) self.acked_flag_list[ window_index] = False # packet delivered to network layer, set the ACK flag to False current_timer = self.timer_list[ window_index] # retrieve any old timer thread if current_timer: # if timer thread exist current_timer.cancel() # cancel the thread self.set_timer(packet, self.next_sequence_number) # set up a new timer thread self.timer_list[window_index].start() self.next_sequence_number += 1 self.sender_lock.release() return
def hist2(datasets, axis1, axis2, bins = None, xmin = None, xmax = None, ymin = None, ymax = None, range_ = None, axes = None, transform = None): datax = util.extract_data(datasets, axis1) datay = util.extract_data(datasets, axis2) titles = util.extract_title(datasets) try: xrange_ = range_[0] yrange_ = range_[1] except: xrange_ = None yrange_ = None xmin, xmax = util.set_limits(datax, xmin, xmax, xrange_, axis1) ymin, ymax = util.set_limits(datay, ymin, ymax, yrange_, axis2) if not isinstance(transform, (list, tuple)): transform = [transform, transform] scaling = [None, None] scaling[0], transform[0] = util.default_scaling(axis1, scaling = scaling[0], transform = transform[0]) scaling[1], transform[1] = util.default_scaling(axis2, scaling = scaling[1], transform = transform[1]) for index, d in enumerate(datax): datax[index] = transform[0](d) for index, d in enumerate(datay): datay[index] = transform[1](d) xmin_transformed, xmax_transformed = util.set_limits(datax) ymin_transformed, ymax_transformed = util.set_limits(datay) # Determine how many bins to use if bins is None: bins = [None, None] if isinstance(bins, int): bins = [bins, bins] bins = list(bins) bins[0] = util.bin_default(axis1, xmin, xmax, bins = bins[0]) bins[1] = util.bin_default(axis2, xmin, xmax, bins = bins[1]) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis1, axis2) # We do not use the Matplotlib API for histograms because we want to have transparent plots # Following example: http://matplotlib.org/examples/api/histogram_path_demo.html den_ = [] range_ = ((xmin_transformed, xmax_transformed),(ymin_transformed, ymax_transformed)) for (dx, dy) in zip(datax, datay): den, xedge, yedge = np.histogram2d(dx, dy, bins = bins, range = range_) den_.append(den) alpha = util.alpha(len(den_)) proxy = [] line_collections = [] levels = 10**np.arange(0,7) for den in den_: line, = ax.plot(0,0) ln = ax.imshow(den.T, cmap = make_cmap(line.get_color()), origin = 'lower', norm = matplotlib.colors.LogNorm(), extent = [xmin, xmax, ymin, ymax], interpolation = 'none', aspect = 'auto') line_collections.append(ln) proxy.append( plt.Rectangle((0,0),1,1,fc = line.get_color(),alpha = alpha)) line.remove() if len(datax) == 1: ax.set_title(titles[0]) elif len(datax) > 1: ax.legend(proxy, titles) ax.set_xlabel(axis1) ax.set_ylabel(axis2) ax.set_xscale(scaling[0]) ax.set_yscale(scaling[1]) return fig
def hist2(datasets, axis1, axis2, bins=None, xmin=None, xmax=None, ymin=None, ymax=None, range_=None, axes=None, transform=None): datax = util.extract_data(datasets, axis1) datay = util.extract_data(datasets, axis2) titles = util.extract_title(datasets) try: xrange_ = range_[0] yrange_ = range_[1] except: xrange_ = None yrange_ = None xmin, xmax = util.set_limits(datax, xmin, xmax, xrange_, axis1) ymin, ymax = util.set_limits(datay, ymin, ymax, yrange_, axis2) if not isinstance(transform, (list, tuple)): transform = [transform, transform] scaling = [None, None] scaling[0], transform[0] = util.default_scaling(axis1, scaling=scaling[0], transform=transform[0]) scaling[1], transform[1] = util.default_scaling(axis2, scaling=scaling[1], transform=transform[1]) for index, d in enumerate(datax): datax[index] = transform[0](d) for index, d in enumerate(datay): datay[index] = transform[1](d) xmin_transformed, xmax_transformed = util.set_limits(datax) ymin_transformed, ymax_transformed = util.set_limits(datay) # Determine how many bins to use if bins is None: bins = [None, None] if isinstance(bins, int): bins = [bins, bins] bins = list(bins) bins[0] = util.bin_default(axis1, xmin, xmax, bins=bins[0]) bins[1] = util.bin_default(axis2, xmin, xmax, bins=bins[1]) fig, ax = util.fig_ax(axes) fig._flowml_axis = (axis1, axis2) # We do not use the Matplotlib API for histograms because we want to have transparent plots # Following example: http://matplotlib.org/examples/api/histogram_path_demo.html den_ = [] range_ = ((xmin_transformed, xmax_transformed), (ymin_transformed, ymax_transformed)) for (dx, dy) in zip(datax, datay): den, xedge, yedge = np.histogram2d(dx, dy, bins=bins, range=range_) den_.append(den) alpha = util.alpha(len(den_)) proxy = [] line_collections = [] levels = 10**np.arange(0, 7) for den in den_: line, = ax.plot(0, 0) ln = ax.imshow(den.T, cmap=make_cmap(line.get_color()), origin='lower', norm=matplotlib.colors.LogNorm(), extent=[xmin, xmax, ymin, ymax], interpolation='none', aspect='auto') line_collections.append(ln) proxy.append( plt.Rectangle((0, 0), 1, 1, fc=line.get_color(), alpha=alpha)) line.remove() if len(datax) == 1: ax.set_title(titles[0]) elif len(datax) > 1: ax.legend(proxy, titles) ax.set_xlabel(axis1) ax.set_ylabel(axis2) ax.set_xscale(scaling[0]) ax.set_yscale(scaling[1]) return fig
def handle_arrival_msg(self): msg = self.network_layer.recv() msg_data = util.extract_data(msg) if (msg_data.is_corrupt): return # If ACK message, assume its for sender if msg_data.msg_type == config.MSG_TYPE_ACK: self.sender_lock.acquire() packet_offset_index = (msg_data.seq_num - self.sender_base) % config.WINDOW_SIZE print(packet_offset_index) self.ack_list[packet_offset_index] = True print('sender cancel timer after receiving ack') util.log("Received ACK with seq #" + util.pkt_to_string(msg_data) + ". Cancelling timer.") self.timer_list[packet_offset_index].cancel() self.timer_list[packet_offset_index] = self.set_timer( msg_data.seq_num) for timer in self.timer_list: print(timer.is_alive()) # check if the packet right after sendbase is ack'd # if yes, move sendbase # update the arrays (timer_list, ack_list) accordingly # by removing first element, and add empty timer, and False ack try: while self.ack_list[0] == True: self.sender_base += 1 util.log(f"Updated send base to {self.sender_base}") self.ack_list = self.ack_list[1:] + [False] self.timer_list = self.timer_list[1:] + [ self.set_timer(-1) ] self.sender_buffer = self.sender_buffer[1:] + [b''] except IndexError: pass self.sender_lock.release() # If DATA message, assume its for receiver else: assert msg_data.msg_type == config.MSG_TYPE_DATA util.log("Received DATA: " + util.pkt_to_string(msg_data)) ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, msg_data.seq_num) if msg_data.seq_num in range( self.receiver_base, self.receiver_base + config.WINDOW_SIZE): self.network_layer.send(ack_pkt) util.log("Sent ACK: " + util.pkt_to_string(util.extract_data(ack_pkt))) packet_offset_index = (msg_data.seq_num - self.receiver_base) % config.WINDOW_SIZE self.rcv_list[packet_offset_index] = True if msg_data.seq_num != self.receiver_base: # Append the payload self.rcv_buffer[packet_offset_index] = msg_data.payload else: # Append the payload self.rcv_buffer[packet_offset_index] = msg_data.payload while self.rcv_list[0] == True: self.msg_handler(self.rcv_buffer[0]) self.receiver_base += 1 self.rcv_list = self.rcv_list[1:] + [False] self.rcv_buffer = self.rcv_buffer[1:] + [b''] util.log( f"Updated receiver base to {self.receiver_base}") elif msg_data.seq_num < self.receiver_base: self.network_layer.send(ack_pkt) util.log("Packet outside receiver window") util.log("Sent ACK: " + util.pkt_to_string(util.extract_data(ack_pkt))) else: return return
def handle_arrival_msg(self): msg = self.network_layer.recv() msg_data = util.extract_data(msg) if (msg_data.is_corrupt): # do nothing # receiver should not send out ACK packet # sender should ignore ACK packet, and wait for timeout to resend packet util.log("Message corrupted: " + util.pkt_to_string(msg_data)) return # If ACK message, assume its for sender if msg_data.msg_type == config.MSG_TYPE_ACK: self.sender_lock.acquire() util.log("Received ACK: " + util.pkt_to_string(msg_data)) target_window_index = (msg_data.seq_num - self.sender_base) % config.WINDOW_SIZE self.acked_flag_list[ target_window_index] = True # set the ACKed flag to True current_timer = self.timer_list[ target_window_index] # retrieve timer thread for the packet if current_timer: current_timer.cancel() # cancel the timer cumulative_acks = 0 # initialize a variable to check cumulative ACKed packet starting from sender_base for hasACKed in self.acked_flag_list: if hasACKed: cumulative_acks += 1 else: break if cumulative_acks > 0: # if has cumulative ACKed packets, slide sender window forward by self.timer_list = self.timer_list[ cumulative_acks:] # removing the timer and ACKed flag that falls out from window self.acked_flag_list = self.acked_flag_list[cumulative_acks:] for i in range(cumulative_acks): # add new default value to self.timer_list.append(None) # timer list self.acked_flag_list.append(False) # ACKed flag list self.sender_lock.release() self.sender_base += cumulative_acks # update sender_base # If DATA message, assume its for receiver else: assert msg_data.msg_type == config.MSG_TYPE_DATA util.log("Received DATA: " + util.pkt_to_string(msg_data)) if ( self.receiver_base - config.WINDOW_SIZE <= msg_data.seq_num <= self.receiver_base - 1 ): # if packet has seq_num in range [receiver_base-N,receiver_base-1] ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, msg_data.seq_num) # send ACK self.network_layer.send(ack_pkt) util.log("Send ACK for seq# : " + util.pkt_to_string(util.extract_data(ack_pkt))) if (msg_data.seq_num >= self.receiver_base ): # if packet has seq_num larger than receiver_base ack_pkt = util.make_packet(b'', config.MSG_TYPE_ACK, msg_data.seq_num) self.network_layer.send(ack_pkt) util.log("Send ACK for seq# : " + util.pkt_to_string(util.extract_data(ack_pkt))) util.log("Added DATA wtih seq# : " + str(msg_data.seq_num) + ' to buffer.') target_window_index = (msg_data.seq_num - self.receiver_base) % config.WINDOW_SIZE self.receiver_buffer[ target_window_index] = msg_data.payload # add packet to buffer self.received_flag_list[ target_window_index] = True # set received flag to True cumulative_seqs = 0 # initialize a variable to check cumulative seq_num in receiver_buffer for hasReceived in self.received_flag_list: if hasReceived: cumulative_seqs += 1 else: break if (cumulative_seqs > 0): # if receiver has cumulative sequence of packets for i in range(cumulative_seqs): self.msg_handler( self.receiver_buffer[i] ) # pass the sequence of packets to application layer self.receiver_buffer = self.receiver_buffer[ cumulative_seqs:] # remove delivered packet from buffer self.received_flag_list = self.received_flag_list[ cumulative_seqs:] # and their respective received status for i in range(cumulative_seqs): # add new default value for self.receiver_buffer.append(None) # receiver buffer self.received_flag_list.append(False) # received flag list self.receiver_base += cumulative_seqs # update receiver_base return
from bs4 import BeautifulSoup import requests from util import save_data_to_file, extract_data url = "http://www.dialadeliverykenya.co.ke/chicken-inn-menu" json_file = "chicken_inn.json" page = requests.get(url) soup = BeautifulSoup(page.content, 'html.parser') items = soup.find_all('div', class_='tab-inner chicken-padder') structured_items = [extract_data(item, url) for item in items] save_data_to_file(structured_items, json_file)
def run_reduction(args): for file_counter, filename in enumerate(args.input_file): print("=================================") print("== Loading data ... ") print("=================================") x, y, opt, h, index = load_data(filename, ans_col=args.answer, ignore_col=args.ignore, header=args.header) save_filename = None if args.output is not None: save_filename = args.output[file_counter] ## 全て欠損の特徴を除去する a = np.all(np.isnan(x), axis=0) ig_index = np.where(a)[0] x = x[:, np.logical_not(a)] args.ignore.extend(ig_index) ## 欠損値を補完(平均) if args.imputer: imr = SimpleImputer(missing_values=np.nan, strategy="mean", verbose=True) x = imr.fit_transform(x) ## 標準化 if args.std: sc = StandardScaler() x = sc.fit_transform(x) print("x:", x.shape) print("y:", y.shape) ## データから2クラス問題か多クラス問題化を決めておく if args.task == "auto": if len(np.unique(y)) == 2: args.task = "binary" else: args.task = "multiclass" # 5つの特徴量を選択 selector = SelectKBest(score_func=f_regression, k=100) mask = ~np.isnan(y) selector.fit(x[mask, :], y[mask]) mask = selector.get_support() print(h) print(mask) print("====") new_h = [] for i, m in enumerate(mask): if m: new_h.append(h[i]) print(new_h) if save_filename is not None: extract_data( filename, save_filename, mask, ans_col=args.answer, ignore_col=args.ignore, header=args.header, )