def __init__(self, url): h_client = http_client.HttpClient(url, token=auth.TEST_TOKEN, secure=CERT) self.follow_client = client.Follow(h_client) self.tweet_client = client.Tweet(h_client) self.feed_client = client.Feed(h_client) self.user_client = client.User(h_client)
def handle_command(command, channel): response = """Not sure what you mean. Please use this construction '@py_compile_bot code,lang'/n Example: @py_compile_bot print(3+7),9""" separated = req.request_conversion(command) dict = {1:"C",2:"C++",3:"D",4:"Haskell",5:"Lua",6:"OCaml",7:"PHP",8:"Perl",9:"Python",10:"Ruby",11:"Scheme",12:"Tcl"} lang_val=dict[int(separated[1])] print lang_val bot = client.User() response = bot.compile(lang_val,separated[0],True) slack_client.api_call("chat.postMessage", channel=channel, text=response, as_user=True)
def __init__(self, login, password, addr, port, parent=None): super().__init__(parent) self.login = login self.password = password self.user = client.User(login=login, password=password, addr=addr, port=port) self.user.connect() self.w = uic.loadUi('GUI\client.ui', self) self.w.setWindowTitle(self.login) # создаём рессивер для перехвата self.listener = GuiReciever(self.user.socket, self.user.request_queue) # создаём поток self.listener.gotData.connect(self.update_chat) self.th = QThread() # ???? self.listener.moveToThread(self.th) # связываем поток с рессивером при приеме данных self.th.started.connect(self.listener.poll) # запускаем поток self.th.start() self.initUT()
def main(): np.random.seed(Config.randomSeed) if not os.path.isdir(Config.figure_path): os.makedirs(Config.figure_path) if not os.path.isdir(Config.download_seq_path): os.makedirs(Config.download_seq_path) if not os.path.isdir(Config.info_data_path): os.makedirs(Config.info_data_path) if not os.path.isdir(Config.represent_file_path): os.makedirs(Config.represent_file_path) # Get traces for simulation video_fovs, v_length = utils.load_fovs_for_video( ) # (48, *) fovs for one video time_traces, bandwidth_traces = utils.load_bw_traces() # Create server video_server = server.Server() server_time, server_seg_idx = video_server.get_current_info() current_time = server_time # Create usrs next_timestamp = [] user_group = [] for i in range(Config.num_users): user_fov = video_fovs[(i + 3) % Config.num_users] time_trace = time_traces[(i + 10) % Config.num_users] bandwidth_trace = bandwidth_traces[(i + 10) % Config.num_users] if Config.latency_optimization: l_group_idx, init_latency, buffer_upper = utils.get_group_idx_optimized( bandwidth_trace) user = client.User(i, l_group_idx, init_latency, user_fov, time_trace, bandwidth_trace, server_seg_idx, v_length, current_time, buffer_upper_bound=buffer_upper) else: # l_group_idx, init_latency = utils.get_group_idx() l_group_idx, init_latency, buffer_upper = utils.get_group_idx_equal( i) user = client.User(i, l_group_idx, init_latency, user_fov, time_trace, bandwidth_trace, server_seg_idx, v_length, current_time, buffer_upper_bound=buffer_upper) user_group.append(user) # Initial fov using initial latencies, push fov to server for u_id in range(len(user_group)): user = user_group[u_id] fov_info = user.generate_fov_info() # To be modified, push to server if len(fov_info): video_server.collect_fov_info(user.get_id(), fov_info, user.get_next_req_seg_idx(), user.get_playing_time(), initial=True) if Config.enable_cache: video_server.find_user_tiers() repre_id, not_repre_id, global_lowest_id = video_server.get_represent() represent_time = current_time represent_file_path = Config.represent_file_path + 'usrs' + str( Config.num_users) + '_coor' + str( Config.coordinate_fov_prediction) + '_latency' + str( Config.latency_optimization) + '.txt' repre_file = open(represent_file_path, 'w') repre_file.write( str(represent_time) + ' ' + str(repre_id[0]) + ' ' + str(repre_id[1]) + ' ' + str(repre_id[2]) + ' ' + str(repre_id[3])) repre_file.write('\n') repre_weight = dict() for beta in range(Config.num_users): repre_weight[beta] = 0.0 # Not repre list, lowest of each group not_represent_file_path = Config.represent_file_path + 'not_usrs' + str( Config.num_users) + '_coor' + str( Config.coordinate_fov_prediction) + '_latency' + str( Config.latency_optimization) + '.txt' not_repre_file = open(not_represent_file_path, 'w') not_repre_file.write( str(represent_time) + ' ' + str(not_repre_id[0]) + ' ' + str(not_repre_id[1]) + ' ' + str(not_repre_id[2]) + ' ' + str(not_repre_id[3])) not_repre_file.write('\n') # Lowest several global global_not_represent_file_path = Config.represent_file_path + 'global_not_usrs' + str( Config.num_users) + '_coor' + str( Config.coordinate_fov_prediction) + '_latency' + str( Config.latency_optimization) + '.txt' global_not_repre_file = open(global_not_represent_file_path, 'w') global_not_repre_file.write(str(represent_time)) for global_lowest in global_lowest_id: global_not_repre_file.write(' ' + str(global_lowest)) global_not_repre_file.write('\n') # Global not weight global_not_w_represent_file_path = Config.represent_file_path + 'global_not_w_usrs' + str( Config.num_users) + '_coor' + str( Config.coordinate_fov_prediction) + '_latency' + str( Config.latency_optimization) + '.txt' global_not_w_repre_file = open(global_not_w_represent_file_path, 'w') global_not_w_repre_file.write(str(represent_time)) for global_lowest in global_lowest_id: global_not_w_repre_file.write(' ' + str(global_lowest)) global_not_w_repre_file.write('\n') # Initial next timestap heap for users event_q = Q.PriorityQueue() for u_id in range(len(user_group)): next_time, events = user_group[u_id].sim_fetching(server_time) event_q.put((next_time, (u_id, events, 0))) if Config.debug: print("Next time is: ", next_time) print(events) # Finish initial, get next updated user and then move system state if Config.enable_cache: download_seq = [] current_cache_file_idx = 0 while not event_q.empty(): next_user_info = event_q.get() next_time = next_user_info[0] u_id = next_user_info[1][0] u_event = next_user_info[1][1] u_action = next_user_info[1][2] user = user_group[u_id] # Do real system evolution if u_action == 0: user_download_seg_idx = user.get_download_seg_idx() # Download next segment seg_info, download_time = user.fetching() tile_idxes, tile_rates = user.get_download_tile_info() user.record_downloaded_tiles( [user_download_seg_idx, seg_info, tile_rates]) user.update_bw_his(seg_info) if Config.enable_cache: # Insert tiles info to cache offset_time = user.get_prefetching_time() new_off = offset_time offset_time += seg_info[0] for tile in seg_info[1:]: if tile[1] == tile[2]: offset_time += tile[3] # Tile id is (seg_idx, pitch_idx, and yaw_idx) rate = tile_rates[tile_idxes.index(tile[0])] tile_id = (user_download_seg_idx, tile[0][0], rate) download_seq.append((offset_time, tile_id, u_id)) if len(download_seq) > 5000: np.savetxt(Config.download_seq_path + 'usrs' + str(Config.num_users) + '_coor' + str(Config.coordinate_fov_prediction) + '_latency' + str(Config.latency_optimization) + '_index' + str(current_cache_file_idx) + '.txt', download_seq, fmt='%s') download_seq = [] current_cache_file_idx += 1 if Config.debug: print("Playing time after fetching: ", user.get_playing_time()) print("Buffer len: ", user.buffer_len) print("Seg info: ", seg_info) print("Sim download time: ", u_event[-1][1] - u_event[0][0]) # print(sum([seg[3] for seg in seg_info[1:]]), seg_info[0]) print("Real download time: ", download_time) # assert np.round(u_event[-1][1] - u_event[0][0]) == np.round(sum([seg[3] for seg in seg_info[1:]]) + seg_info[0]) elif u_action == 1: # Wait wait_time = next_user_info[1][3] user.wait(wait_time) if Config.debug and u_id == 0: print("u 0 next time: ", next_time) print("gap is: ", next_time - current_time) video_server.update(next_time - current_time) current_time = next_time ############################################################### # Get represent from server calculate distance, seems not work well # if Config.enable_cache: # if current_time - represent_time >= Config.represent_update_interval: # represent_time = current_time # repre_id = video_server.get_represent() # repre_file.write(str(represent_time) + ' ' + str(repre_id)) # repre_file.write('\n') ############################################################### user.udpate_prefetching_time(current_time) # Check whether buffer exceed or server wait if Config.debug: print( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" ) print( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" ) print( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" ) print( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" ) server_time, server_seg_idx = video_server.get_current_info() player_buffer_len = user.get_buffer_length() # print("Player buff: ", player_buffer_len) user_req_seg_idx = user.get_next_req_seg_idx() buffer_wait_time = max( 0.0, player_buffer_len - user.get_buffer_upper_bound()) # print("Wait time is:", buffer_wait_time) server_wait_time = 0.0 # assert user_req_seg_idx <= server_seg_idx if user_req_seg_idx == server_seg_idx: server_wait_time = Config.seg_duration - server_time % Config.seg_duration wait_time = max(buffer_wait_time, server_wait_time) if wait_time == 0: # Upload fov to server fov_info = user.generate_fov_info() if len(fov_info): video_server.collect_fov_info(u_id, fov_info, user.get_next_req_seg_idx(), user.get_playing_time()) # Do prediction on this user using all infomation if wait_time > 0.0: next_time, events = user.sim_wait(server_time, wait_time) event_q.put((next_time, (u_id, events, 1, wait_time))) if Config.debug: print("Next time is (wait): ", next_time) print(events) else: if user.check_ending(): # No more fov trace continue # If next step is to download, predict bw and fov #################################################################### #################################################################### predicted_bw = user.predict_bw() prepared_info, predicted_seg_idx, display_segs, predicted_center = user.predict_fov( ) neighbor_fovs, neighbor_dis_maps = video_server.get_user_fovs( display_segs, predicted_seg_idx) betas = user.choose_tiles(predicted_seg_idx, predicted_bw, prepared_info, predicted_center, neighbor_fovs, neighbor_dis_maps) # if Config.enable_cache: for beta in betas: repre_weight[beta[0]] += beta[1] if current_time - represent_time >= Config.represent_update_interval: # First of all, cluster users based on latency represent_time = current_time tmp_repre_list = [] time_info_list = [0.0] * Config.num_users for user_id in range(Config.num_users): tmp_user = user_group[user_id] user_playing_time = tmp_user.get_playing_time() time_info_list[user_id] = (user_id, user_playing_time) # Do clustering time_info_list.sort(key=lambda x: x[1], reverse=True) # # Method 1: Select the one with highest weight from each group # for group_i in range(4): # Four groups # group_users_id = [u[0] for u in time_info_list[group_i*int(Config.num_users/4):(group_i+1)*int(Config.num_users/4)]] # curr_group_weight = [(g_user_id, repre_weight[g_user_id]) for g_user_id in group_users_id] # curr_group_repre = max(curr_group_weight, key=lambda x:x[1])[0] # tmp_repre_list.append(curr_group_repre) # Method 2: Select the one with shortest latecy in each group diff = [(u_time_idx, time_info_list[u_time_idx][1] - time_info_list[u_time_idx - 1][1]) for u_time_idx in range(1, len(time_info_list))] diff.sort(key=lambda x: x[1]) for break_id in diff[:3]: tmp_repre_list.append(break_id[0]) tmp_repre_list.append(time_info_list[0][0]) assert len(tmp_repre_list) == 4 repre_file.write( str(represent_time) + ' ' + str(tmp_repre_list[0]) + ' ' + str(tmp_repre_list[1]) + ' ' + str(tmp_repre_list[2]) + ' ' + str(tmp_repre_list[3])) repre_file.write('\n') # Find lowest users not_tmp_repre_list = [] for break_id in diff[:3]: not_tmp_repre_list.append(break_id[0] - 1) not_tmp_repre_list.append(time_info_list[-1][0]) not_repre_file.write( str(represent_time) + ' ' + str(not_tmp_repre_list[0]) + ' ' + str(not_tmp_repre_list[1]) + ' ' + str(not_tmp_repre_list[2]) + ' ' + str(not_tmp_repre_list[3])) not_repre_file.write('\n') # Global lowest 10 users global_not_repre_list = [ x[0] for x in time_info_list[int(-Config.num_users / 6):] ] global_not_repre_file.write(str(represent_time)) for global_not_repre in global_not_repre_list: global_not_repre_file.write(' ' + str(global_not_repre)) global_not_repre_file.write('\n') # Global lowest 10 users global_not_w_repre_list = [ x[0] for x in time_info_list[int(-Config.num_users / 4):] ] curr_w_group_weight = [ (g_user_id, repre_weight[g_user_id]) for g_user_id in global_not_w_repre_list ] curr_w_group_weight.sort(key=lambda x: x[1]) global_not_w_repre = [ x[0] for x in curr_w_group_weight[:int(Config.num_users / 6)] ] global_not_w_repre_file.write(str(represent_time)) for global_not_repre in global_not_w_repre: global_not_w_repre_file.write(' ' + str(global_not_repre)) global_not_w_repre_file.write('\n') for key, value in repre_weight.items(): repre_weight[key] = 0.0 #################################################################### #################################################################### next_time, events = user.sim_fetching(server_time) event_q.put((next_time, (u_id, events, 0))) if Config.debug: print("Next time is (fetching): ", next_time) print(events) # Put back to pq # Record all mapping/trace/userid mapping_path = Config.info_data_path + 'Mapping_usrs' + str( Config.num_users) + '_coor' + str( Config.coordinate_fov_prediction) + '_latency' + str( Config.latency_optimization) + '.txt' log_file = open(mapping_path, 'w') # Evaluate performance for user in user_group: rates, freeze, cross_entropy = user.evaluate_performance() time_trace, bw_trace = user.get_sim_bw_trace() # utils.plot_metrics(user.get_id(), time_trace, bw_trace, rates, freeze) log_file.write('User: '******' FoV ID: ' + str(user.fov_trace_id) + ' BW Trace ID: ' + str(user.bw_trace_id) + ' Latency group: ' + str(user.l_group_idx)) log_file.write('\n') log_file.write(' # Segs: ' + str(len(rates)) + ' Ave rates: ' + str(np.mean([rate[1] for rate in rates]))) log_file.write(' Total freezing: ' + str(np.sum([f[1] for f in freeze]))) log_file.write(' Average cross_entropy: ' + str(np.mean([c_e[1] for c_e in cross_entropy]))) log_file.write('\n') log_file.write if Config.enable_cache: np.savetxt(Config.download_seq_path + 'usrs' + str(Config.num_users) + '_coor' + str(Config.coordinate_fov_prediction) + '_latency' + str(Config.latency_optimization) + '_index' + str(current_cache_file_idx) + '.txt', download_seq, fmt='%s')
def setup(self): self.user = client.User('Name', 'password')