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)
## データから２クラス問題か多クラス問題化を決めておく
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,
)
